diff --git a/.github/scripts/analyze.sh b/.github/scripts/analyze.sh
index 674b3b8210..a5c57b7b9d 100755
--- a/.github/scripts/analyze.sh
+++ b/.github/scripts/analyze.sh
@@ -4,4 +4,5 @@ set -eux
 ./gradlew \
     forbiddenApis -DforbiddenApis \
     pmdJavaPoet pmdMain pmdCodeGen pmdJmh -Dpmd \
-    spotbugsJavaPoet spotbugsMain spotbugsCodeGen spotbugsJmh -Dspotbugs
+    spotbugsJavaPoet spotbugsMain spotbugsCodeGen spotbugsJmh -Dspotbugs \
+    "$@"
diff --git a/caffeine/build.gradle.kts b/caffeine/build.gradle.kts
index 30df549013..b46052a16c 100644
--- a/caffeine/build.gradle.kts
+++ b/caffeine/build.gradle.kts
@@ -2,6 +2,7 @@ import com.google.common.collect.Sets
 import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApis
 import kotlin.math.max
 import net.ltgt.gradle.errorprone.errorprone
+import net.ltgt.gradle.nullaway.nullaway
 import org.gradle.api.tasks.PathSensitivity.RELATIVE
 import org.gradle.plugins.ide.eclipse.model.Classpath as EclipseClasspath
 import org.gradle.plugins.ide.eclipse.model.Library
@@ -78,6 +79,13 @@ val compileCodeGenJava by tasks.existing(JavaCompile::class) {
   classpath = sourceSets["main"].runtimeClasspath + sourceSets["main"].output
   dependsOn(tasks.compileJava)
   options.isDebug = false
+
+  options.errorprone {
+    disable("FieldMissingNullable")
+    disable("MissingOverride")
+    disable("Varifier")
+    nullaway.disable()
+  }
 }
 
 compileJavaPoetJava.configure {
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/LocalCacheFactoryGenerator.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/LocalCacheFactoryGenerator.java
index b9b718a1d8..c81e2061f3 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/LocalCacheFactoryGenerator.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/LocalCacheFactoryGenerator.java
@@ -95,8 +95,8 @@ private void generate() throws FormatterException, IOException {
   }
 
   private void writeJavaFile() throws IOException {
-    String header = Resources.toString(Resources.getResource("license.txt"), UTF_8).trim();
-    ZoneId timeZone = ZoneId.of("America/Los_Angeles");
+    var header = Resources.toString(Resources.getResource("license.txt"), UTF_8).trim();
+    var timeZone = ZoneId.of("America/Los_Angeles");
     for (TypeSpec typeSpec : factoryTypes) {
       JavaFile.builder(getClass().getPackageName(), typeSpec)
           .addFileComment(header, Year.now(timeZone))
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/NodeFactoryGenerator.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/NodeFactoryGenerator.java
index 961fd2a726..85df35469f 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/NodeFactoryGenerator.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/NodeFactoryGenerator.java
@@ -98,7 +98,7 @@ private void generate() throws FormatterException, IOException {
 
   private void writeJavaFile() throws IOException {
     String header = Resources.toString(Resources.getResource("license.txt"), UTF_8).trim();
-    ZoneId timeZone = ZoneId.of("America/Los_Angeles");
+    var timeZone = ZoneId.of("America/Los_Angeles");
     for (TypeSpec node : nodeTypes) {
       JavaFile.builder(getClass().getPackage().getName(), node)
           .addFileComment(header, Year.now(timeZone))
@@ -185,7 +185,7 @@ private TypeSpec makeNodeSpec(String className, boolean isFinal, ImmutableSet<Fe
     return context.build();
   }
 
-  private Set<List<Object>> combinations() {
+  private static Set<List<Object>> combinations() {
     var keyStrengths = Set.of(Feature.STRONG_KEYS, Feature.WEAK_KEYS);
     var valueStrengths = Set.of(Feature.STRONG_VALUES, Feature.WEAK_VALUES, Feature.SOFT_VALUES);
     var expireAfterAccess = Set.of(false, true);
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddDeques.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddDeques.java
index ebfef800d2..98eb7d5d72 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddDeques.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddDeques.java
@@ -42,7 +42,7 @@ public void execute(LocalCacheContext context) {
     addWriteOrderDeque(context);
   }
 
-  private void addAccessOrderWindowDeque(LocalCacheContext context) {
+  private static void addAccessOrderWindowDeque(LocalCacheContext context) {
     if (Feature.usesAccessOrderWindowDeque(context.parentFeatures)
         || !Feature.usesAccessOrderWindowDeque(context.generateFeatures)) {
       return;
@@ -52,38 +52,35 @@ private void addAccessOrderWindowDeque(LocalCacheContext context) {
         "this.$L = builder.evicts() || builder.expiresAfterAccess()\n? new $T()\n: null",
         "accessOrderWindowDeque", ACCESS_ORDER_DEQUE);
     addFieldAndMethod(context, ACCESS_ORDER_DEQUE, "accessOrderWindowDeque");
-    context.suppressedWarnings.add("NullAway");
   }
 
-  private void addAccessOrderMainDeque(LocalCacheContext context) {
+  private static void addAccessOrderMainDeque(LocalCacheContext context) {
     if (Feature.usesAccessOrderMainDeque(context.parentFeatures)
         || !Feature.usesAccessOrderMainDeque(context.generateFeatures)) {
       return;
     }
     addDeque(context, ACCESS_ORDER_DEQUE, "accessOrderProbationDeque");
     addDeque(context, ACCESS_ORDER_DEQUE, "accessOrderProtectedDeque");
-    context.suppressedWarnings.add("NullAway");
   }
 
-  private void addWriteOrderDeque(LocalCacheContext context) {
+  private static void addWriteOrderDeque(LocalCacheContext context) {
     if (Feature.usesWriteOrderDeque(context.parentFeatures)
         || !Feature.usesWriteOrderDeque(context.generateFeatures)) {
       return;
     }
     addDeque(context, WRITE_ORDER_DEQUE, "writeOrderDeque");
-    context.suppressedWarnings.add("NullAway");
   }
 
-  private void addDeque(LocalCacheContext context, TypeName type, String name) {
+  private static void addDeque(LocalCacheContext context, TypeName type, String name) {
     addConstructor(context, type, name);
     addFieldAndMethod(context, type, name);
   }
 
-  private void addConstructor(LocalCacheContext context, TypeName type, String name) {
+  private static void addConstructor(LocalCacheContext context, TypeName type, String name) {
     context.constructor.addStatement("this.$L = new $T()", name, type);
   }
 
-  private void addFieldAndMethod(LocalCacheContext context, TypeName type, String name) {
+  private static void addFieldAndMethod(LocalCacheContext context, TypeName type, String name) {
     context.cache.addField(FieldSpec.builder(type, name, Modifier.FINAL).build());
     context.cache.addMethod(MethodSpec.methodBuilder(name)
         .addModifiers(context.protectedFinalModifiers())
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddExpireAfterAccess.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddExpireAfterAccess.java
index 8e07e9a766..45a03c8d22 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddExpireAfterAccess.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddExpireAfterAccess.java
@@ -36,12 +36,11 @@ public boolean applies(LocalCacheContext context) {
 
   @Override
   public void execute(LocalCacheContext context) {
-    context.suppressedWarnings.add("NullAway");
     variableExpiration(context);
     fixedExpiration(context);
   }
 
-  private void fixedExpiration(LocalCacheContext context) {
+  private static void fixedExpiration(LocalCacheContext context) {
     context.constructor.addStatement(
         "this.expiresAfterAccessNanos = builder.getExpiresAfterAccessNanos()");
     context.cache.addField(FieldSpec.builder(long.class, "expiresAfterAccessNanos")
@@ -63,7 +62,7 @@ private void fixedExpiration(LocalCacheContext context) {
         .build());
   }
 
-  private void variableExpiration(LocalCacheContext context) {
+  private static void variableExpiration(LocalCacheContext context) {
     context.cache.addMethod(MethodSpec.methodBuilder("expiresVariable")
         .addModifiers(context.protectedFinalModifiers())
         .addStatement("return (timerWheel != null)")
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddKeyValueStrength.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddKeyValueStrength.java
index 225b5e4723..f111617bfc 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddKeyValueStrength.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddKeyValueStrength.java
@@ -41,20 +41,20 @@ public void execute(LocalCacheContext context) {
     addValueStrength(context);
   }
 
-  private void addKeyStrength(LocalCacheContext context) {
+  private static void addKeyStrength(LocalCacheContext context) {
     if (context.generateFeatures.contains(Feature.WEAK_KEYS)) {
       addStrength(context, "collectKeys", "keyReferenceQueue", kRefQueueType);
     }
   }
 
-  private void addValueStrength(LocalCacheContext context) {
+  private static void addValueStrength(LocalCacheContext context) {
     if (context.generateFeatures.contains(Feature.INFIRM_VALUES)) {
       addStrength(context, "collectValues", "valueReferenceQueue", vRefQueueType);
     }
   }
 
   /** Adds the reference strength methods for the key or value. */
-  private void addStrength(LocalCacheContext context,
+  private static void addStrength(LocalCacheContext context,
       String collectName, String queueName, TypeName type) {
     context.cache.addMethod(MethodSpec.methodBuilder(queueName)
         .addModifiers(context.protectedFinalModifiers())
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddMaximum.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddMaximum.java
index eecfbc6d65..4da82044da 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddMaximum.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddMaximum.java
@@ -44,7 +44,7 @@ public void execute(LocalCacheContext context) {
     addFrequencySketch(context);
   }
 
-  private void addEvicts(LocalCacheContext context) {
+  private static void addEvicts(LocalCacheContext context) {
     context.cache.addMethod(MethodSpec.methodBuilder("evicts")
         .addModifiers(context.protectedFinalModifiers())
         .addStatement("return true")
@@ -52,7 +52,7 @@ private void addEvicts(LocalCacheContext context) {
         .build());
   }
 
-  private void addMaximumSize(LocalCacheContext context) {
+  private static void addMaximumSize(LocalCacheContext context) {
     addField(context, long.class, "maximum");
     addField(context, long.class, "weightedSize");
     addField(context, long.class, "windowMaximum");
@@ -61,7 +61,7 @@ private void addMaximumSize(LocalCacheContext context) {
     addField(context, long.class, "mainProtectedWeightedSize");
   }
 
-  private void addHillClimber(LocalCacheContext context) {
+  private static void addHillClimber(LocalCacheContext context) {
     addField(context, double.class, "stepSize");
     addField(context, long.class, "adjustment");
     addField(context, int.class, "hitsInSample");
@@ -69,7 +69,7 @@ private void addHillClimber(LocalCacheContext context) {
     addField(context, double.class, "previousSampleHitRate");
   }
 
-  private void addFrequencySketch(LocalCacheContext context) {
+  private static void addFrequencySketch(LocalCacheContext context) {
     context.cache.addField(FieldSpec.builder(
         FREQUENCY_SKETCH, "sketch", Modifier.FINAL).build());
     context.constructor.addCode(CodeBlock.builder()
@@ -86,7 +86,7 @@ private void addFrequencySketch(LocalCacheContext context) {
         .build());
   }
 
-  private void addField(LocalCacheContext context, Class<?> type, String name) {
+  private static void addField(LocalCacheContext context, Class<?> type, String name) {
     context.cache.addField(FieldSpec.builder(type, name).build());
     context.cache.addMethod(MethodSpec.methodBuilder(name)
         .addModifiers(context.protectedFinalModifiers())
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddRemovalListener.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddRemovalListener.java
index 214dd01adc..e352954b45 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddRemovalListener.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddRemovalListener.java
@@ -35,7 +35,6 @@ public boolean applies(LocalCacheContext context) {
 
   @Override
   public void execute(LocalCacheContext context) {
-    context.suppressedWarnings.add("NullAway");
     context.cache.addField(
         FieldSpec.builder(REMOVAL_LISTENER, "removalListener", Modifier.FINAL).build());
     context.constructor.addStatement("this.removalListener = builder.getRemovalListener(async)");
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddStats.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddStats.java
index 57bce1ec05..3063ca29f4 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddStats.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddStats.java
@@ -41,7 +41,7 @@ public void execute(LocalCacheContext context) {
     addStatsCounter(context);
   }
 
-  private void addIsRecording(LocalCacheContext context) {
+  private static void addIsRecording(LocalCacheContext context) {
     context.cache.addMethod(MethodSpec.methodBuilder("isRecordingStats")
         .addModifiers(context.publicFinalModifiers())
         .addStatement("return true")
@@ -49,7 +49,7 @@ private void addIsRecording(LocalCacheContext context) {
         .build());
   }
 
-  private void addStatsCounter(LocalCacheContext context) {
+  private static void addStatsCounter(LocalCacheContext context) {
     context.constructor.addStatement("this.statsCounter = builder.getStatsCounterSupplier().get()");
     context.cache.addField(FieldSpec.builder(
         STATS_COUNTER, "statsCounter", Modifier.FINAL).build());
@@ -60,7 +60,7 @@ private void addStatsCounter(LocalCacheContext context) {
         .build());
   }
 
-  private void addStatsTicker(LocalCacheContext context) {
+  private static void addStatsTicker(LocalCacheContext context) {
     context.cache.addMethod(MethodSpec.methodBuilder("statsTicker")
         .addModifiers(context.publicFinalModifiers())
         .addStatement("return $T.systemTicker()", TICKER)
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddSubtype.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddSubtype.java
index 5c91cd3a6c..19ea059344 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddSubtype.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/local/AddSubtype.java
@@ -37,7 +37,6 @@ public boolean applies(LocalCacheContext context) {
 
   @Override
   public void execute(LocalCacheContext context) {
-    context.suppressedWarnings.add("MissingOverride");
     context.cache.superclass(context.superClass)
         .addJavadoc(getJavaDoc(context))
         .addTypeVariable(kTypeVar)
@@ -47,8 +46,8 @@ public void execute(LocalCacheContext context) {
     }
   }
 
-  private String getJavaDoc(LocalCacheContext context) {
-    StringBuilder doc = new StringBuilder(200);
+  private static String getJavaDoc(LocalCacheContext context) {
+    var doc = new StringBuilder(200);
     doc.append("<em>WARNING: GENERATED CODE</em>\n\n"
         + "A cache that provides the following features:\n<ul>");
     for (Feature feature : context.generateFeatures) {
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddConstructors.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddConstructors.java
index ddc7fc9dff..ae5eef9f06 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddConstructors.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddConstructors.java
@@ -18,6 +18,7 @@
 import static com.github.benmanes.caffeine.cache.Specifications.keyRefQueueSpec;
 import static com.github.benmanes.caffeine.cache.Specifications.valueRefQueueSpec;
 import static com.github.benmanes.caffeine.cache.Specifications.valueSpec;
+import static com.github.benmanes.caffeine.cache.node.NodeContext.varHandleName;
 
 import com.squareup.javapoet.MethodSpec;
 
@@ -37,14 +38,13 @@ public boolean applies(NodeContext context) {
   public void execute(NodeContext context) {
     addConstructorByKey(context);
     addConstructorByKeyRef(context);
-    context.suppressedWarnings.add("NullAway");
     if (context.isBaseClass()) {
       context.suppressedWarnings.add("PMD.UnusedFormalParameter");
     }
   }
 
   /** Adds the constructor by key to the node type. */
-  private void addConstructorByKey(NodeContext context) {
+  private static void addConstructorByKey(NodeContext context) {
     context.constructorByKey.addParameter(keyRefQueueSpec);
     addCommonParameters(context.constructorByKey);
     if (context.isBaseClass()) {
@@ -55,7 +55,7 @@ private void addConstructorByKey(NodeContext context) {
   }
 
   /** Adds the constructor by key reference to the node type. */
-  private void addConstructorByKeyRef(NodeContext context) {
+  private static void addConstructorByKeyRef(NodeContext context) {
     addCommonParameters(context.constructorByKeyRef);
     if (context.isBaseClass()) {
       assignKeyRefAndValue(context);
@@ -64,14 +64,14 @@ private void addConstructorByKeyRef(NodeContext context) {
     }
   }
 
-  private void addCommonParameters(MethodSpec.Builder constructor) {
+  private static void addCommonParameters(MethodSpec.Builder constructor) {
     constructor.addParameter(valueSpec);
     constructor.addParameter(valueRefQueueSpec);
     constructor.addParameter(int.class, "weight");
     constructor.addParameter(long.class, "now");
   }
 
-  private void callSiblingConstructor(NodeContext context) {
+  private static void callSiblingConstructor(NodeContext context) {
     if (context.isStrongKeys()) {
       context.constructorByKey.addStatement("this(key, value, valueReferenceQueue, weight, now)");
     } else {
@@ -81,25 +81,25 @@ private void callSiblingConstructor(NodeContext context) {
     }
   }
 
-  private void assignKeyRefAndValue(NodeContext context) {
+  private static void assignKeyRefAndValue(NodeContext context) {
     if (context.isStrongValues()) {
       context.constructorByKeyRef.addStatement("$L.set(this, $N)",
-          context.varHandleName("key"), "keyReference");
+          varHandleName("key"), "keyReference");
       context.constructorByKeyRef.addStatement("$L.set(this, $N)",
-          context.varHandleName("value"), "value");
+          varHandleName("value"), "value");
     } else {
       context.constructorByKeyRef.addStatement("$L.set(this, new $T($N, $N, $N))",
-          context.varHandleName("value"), context.valueReferenceType(),
+          varHandleName("value"), context.valueReferenceType(),
           "keyReference", "value", "valueReferenceQueue");
     }
   }
 
-  private void callParentByKey(NodeContext context) {
+  private static void callParentByKey(NodeContext context) {
     context.constructorByKey.addStatement(
         "super(key, keyReferenceQueue, value, valueReferenceQueue, weight, now)");
   }
 
-  private void callParentByKeyRef(NodeContext context) {
+  private static void callParentByKeyRef(NodeContext context) {
     context.constructorByKeyRef.addStatement(
         "super(keyReference, value, valueReferenceQueue, weight, now)");
   }
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddDeques.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddDeques.java
index f43eb0dbf1..004438d1c4 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddDeques.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddDeques.java
@@ -48,7 +48,7 @@ public void execute(NodeContext context) {
   }
 
   /** Adds a simple field, accessor, and mutator for the variable. */
-  private void addFieldAndGetter(NodeContext context, String varName) {
+  private static void addFieldAndGetter(NodeContext context, String varName) {
     context.nodeSubtype.addField(NODE, varName)
         .addMethod(context.newGetter(Strength.STRONG, NODE, varName, Visibility.VOLATILE))
         .addMethod(context.newSetter(NODE, varName, Visibility.VOLATILE));
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddExpiration.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddExpiration.java
index ee8bf4ea4e..50d36d038a 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddExpiration.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddExpiration.java
@@ -16,6 +16,7 @@
 package com.github.benmanes.caffeine.cache.node;
 
 import static com.github.benmanes.caffeine.cache.Specifications.NODE;
+import static com.github.benmanes.caffeine.cache.node.NodeContext.varHandleName;
 import static org.apache.commons.lang3.StringUtils.capitalize;
 
 import javax.lang.model.element.Modifier;
@@ -46,7 +47,7 @@ public void execute(NodeContext context) {
     addRefreshExpiration(context);
   }
 
-  private void addVariableExpiration(NodeContext context) {
+  private static void addVariableExpiration(NodeContext context) {
     if (context.generateFeatures.contains(Feature.EXPIRE_ACCESS)) {
       addLink(context, "previousInVariableOrder", "previousInAccessOrder");
       addLink(context, "nextInVariableOrder", "nextInAccessOrder");
@@ -65,7 +66,7 @@ private void addVariableExpiration(NodeContext context) {
     }
   }
 
-  private void addLink(NodeContext context, String method, String varName) {
+  private static void addLink(NodeContext context, String method, String varName) {
     var getter = MethodSpec.methodBuilder("get" + capitalize(method))
         .addModifiers(Modifier.PUBLIC)
         .addStatement("return $N", varName)
@@ -81,16 +82,16 @@ private void addLink(NodeContext context, String method, String varName) {
         .addMethod(setter);
   }
 
-  private void addVariableTime(NodeContext context, String varName) {
+  private static void addVariableTime(NodeContext context, String varName) {
     var getter = MethodSpec.methodBuilder("getVariableTime")
         .addModifiers(Modifier.PUBLIC)
-        .addStatement("return (long) $L.getOpaque(this)", context.varHandleName(varName))
+        .addStatement("return (long) $L.getOpaque(this)", varHandleName(varName))
         .returns(long.class)
         .build();
     var setter = MethodSpec.methodBuilder("setVariableTime")
         .addModifiers(Modifier.PUBLIC)
         .addParameter(long.class, varName)
-        .addStatement("$L.setOpaque(this, $N)", context.varHandleName(varName), varName)
+        .addStatement("$L.setOpaque(this, $N)", varHandleName(varName), varName)
         .build();
     var cas = MethodSpec.methodBuilder("casVariableTime")
         .addModifiers(Modifier.PUBLIC)
@@ -98,7 +99,7 @@ private void addVariableTime(NodeContext context, String varName) {
         .addParameter(long.class, "update")
         .returns(boolean.class)
         .addStatement("return ($N == $N)\n&& $L.compareAndSet(this, $N, $N)",
-            varName, "expect", context.varHandleName(varName), "expect", "update")
+            varName, "expect", varHandleName(varName), "expect", "update")
         .build();
     context.nodeSubtype
         .addMethod(getter)
@@ -106,7 +107,7 @@ private void addVariableTime(NodeContext context, String varName) {
         .addMethod(cas);
   }
 
-  private void addAccessExpiration(NodeContext context) {
+  private static void addAccessExpiration(NodeContext context) {
     if (!context.generateFeatures.contains(Feature.EXPIRE_ACCESS)) {
       return;
     }
@@ -117,11 +118,11 @@ private void addAccessExpiration(NodeContext context) {
             TypeName.LONG, "accessTime", Visibility.OPAQUE))
         .addMethod(context.newSetter(TypeName.LONG, "accessTime", Visibility.OPAQUE));
     context.addVarHandle("accessTime", TypeName.get(long.class));
-    addTimeConstructorAssignment(context, context.constructorByKey, "accessTime", "now");
-    addTimeConstructorAssignment(context, context.constructorByKeyRef, "accessTime", "now");
+    addTimeConstructorAssignment(context.constructorByKey, "accessTime", "now");
+    addTimeConstructorAssignment(context.constructorByKeyRef, "accessTime", "now");
   }
 
-  private void addWriteExpiration(NodeContext context) {
+  private static void addWriteExpiration(NodeContext context) {
     if (!Feature.useWriteTime(context.parentFeatures)
         && Feature.useWriteTime(context.generateFeatures)) {
       context.nodeSubtype
@@ -130,12 +131,12 @@ private void addWriteExpiration(NodeContext context) {
               TypeName.LONG, "writeTime", Visibility.OPAQUE))
           .addMethod(context.newSetter(TypeName.LONG, "writeTime", Visibility.PLAIN));
       context.addVarHandle("writeTime", TypeName.get(long.class));
-      addTimeConstructorAssignment(context, context.constructorByKey, "writeTime", "now & ~1L");
-      addTimeConstructorAssignment(context, context.constructorByKeyRef, "writeTime", "now & ~1L");
+      addTimeConstructorAssignment(context.constructorByKey, "writeTime", "now & ~1L");
+      addTimeConstructorAssignment(context.constructorByKeyRef, "writeTime", "now & ~1L");
     }
   }
 
-  private void addRefreshExpiration(NodeContext context) {
+  private static void addRefreshExpiration(NodeContext context) {
     if (!context.generateFeatures.contains(Feature.REFRESH_WRITE)) {
       return;
     }
@@ -145,13 +146,13 @@ private void addRefreshExpiration(NodeContext context) {
         .addParameter(long.class, "update")
         .returns(boolean.class)
         .addStatement("return ($N == $N)\n&& $L.compareAndSet(this, $N, $N)",
-            "writeTime", "expect", context.varHandleName("writeTime"), "expect", "update")
+            "writeTime", "expect", varHandleName("writeTime"), "expect", "update")
         .build());
   }
 
   /** Adds a long constructor assignment. */
-  private void addTimeConstructorAssignment(NodeContext context,
+  private static void addTimeConstructorAssignment(
       MethodSpec.Builder constructor, String field, String value) {
-    constructor.addStatement("$L.set(this, $N)", context.varHandleName(field), value);
+    constructor.addStatement("$L.set(this, $N)", varHandleName(field), value);
   }
 }
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddFactoryMethods.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddFactoryMethods.java
index bb1a844b04..c4016f0a9e 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddFactoryMethods.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddFactoryMethods.java
@@ -55,7 +55,7 @@ public void execute(NodeContext context) {
     }
   }
 
-  private void addFactories(NodeContext context) {
+  private static void addFactories(NodeContext context) {
     context.nodeSubtype.addMethod(
         newNode(keySpec, keyRefQueueSpec)
             .addStatement("return new $N<>(key, keyReferenceQueue, value, "
@@ -68,7 +68,7 @@ private void addFactories(NodeContext context) {
             .build());
   }
 
-  private void addWeakKeys(NodeContext context) {
+  private static void addWeakKeys(NodeContext context) {
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder("newLookupKey")
         .addModifiers(Modifier.PUBLIC)
         .addParameter(Object.class, "key")
@@ -84,7 +84,7 @@ private void addWeakKeys(NodeContext context) {
         .build());
   }
 
-  private void addSoftValues(NodeContext context) {
+  private static void addSoftValues(NodeContext context) {
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder("softValues")
         .addModifiers(Modifier.PUBLIC)
         .addStatement("return true")
@@ -92,7 +92,7 @@ private void addSoftValues(NodeContext context) {
         .build());
   }
 
-  private void addWeakValues(NodeContext context) {
+  private static void addWeakValues(NodeContext context) {
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder("weakValues")
         .addModifiers(Modifier.PUBLIC)
         .addStatement("return true")
@@ -100,7 +100,7 @@ private void addWeakValues(NodeContext context) {
         .build());
   }
 
-  private MethodSpec.Builder newNode(ParameterSpec... keyParams) {
+  private static MethodSpec.Builder newNode(ParameterSpec... keyParams) {
     return MethodSpec.methodBuilder("newNode")
         .addModifiers(Modifier.PUBLIC)
         .addParameters(ImmutableList.copyOf(keyParams))
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddHealth.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddHealth.java
index 5ff212e874..492b1d70a2 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddHealth.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddHealth.java
@@ -20,6 +20,7 @@
 import static com.github.benmanes.caffeine.cache.Specifications.RETIRED_STRONG_KEY;
 import static com.github.benmanes.caffeine.cache.Specifications.RETIRED_WEAK_KEY;
 import static com.github.benmanes.caffeine.cache.Specifications.referenceType;
+import static com.github.benmanes.caffeine.cache.node.NodeContext.varHandleName;
 
 import com.github.benmanes.caffeine.cache.node.NodeContext.Strength;
 import com.squareup.javapoet.MethodSpec;
@@ -54,12 +55,12 @@ public void execute(NodeContext context) {
         .addModifiers(context.publicFinalModifiers())
         .returns(boolean.class)
         .build());
-    addState(context, "isRetired", "retire", retiredArg, false);
-    addState(context, "isDead", "die", deadArg, true);
+    addState(context, "isRetired", "retire", retiredArg, /* finalized= */ false);
+    addState(context, "isDead", "die", deadArg, /* finalized= */ true);
   }
 
-  private void addState(NodeContext context, String checkName
-      , String actionName, String arg, boolean finalized) {
+  private static void addState(NodeContext context, String checkName,
+      String actionName, String arg, boolean finalized) {
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder(checkName)
         .addStatement("return (getKeyReference() == $L)", arg)
         .addModifiers(context.publicFinalModifiers())
@@ -75,12 +76,12 @@ private void addState(NodeContext context, String checkName
       // Set the value to null only when dead, as otherwise the explicit removal of an expired async
       // value will be notified as explicit rather than expired due to the isComputingAsync() check
       if (finalized) {
-        action.addStatement("$L.set(this, null)", context.varHandleName("value"));
+        action.addStatement("$L.set(this, null)", varHandleName("value"));
       }
-      action.addStatement("$L.set(this, $N)", context.varHandleName("key"), arg);
+      action.addStatement("$L.set(this, $N)", varHandleName("key"), arg);
     } else {
       action.addStatement("$1T valueRef = ($1T) $2L.get(this)",
-          context.valueReferenceType(), context.varHandleName("value"));
+          context.valueReferenceType(), varHandleName("value"));
       if (context.keyStrength() != Strength.STRONG) {
         action.addStatement("$1T keyRef = ($1T) valueRef.getKeyReference()", referenceType);
         action.addStatement("keyRef.clear()");
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddKey.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddKey.java
index bab6b1b24c..8bde464223 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddKey.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddKey.java
@@ -17,8 +17,7 @@
 
 import static com.github.benmanes.caffeine.cache.Specifications.kTypeVar;
 import static com.github.benmanes.caffeine.cache.Specifications.referenceType;
-
-import java.util.List;
+import static com.github.benmanes.caffeine.cache.node.NodeContext.varHandleName;
 
 import javax.lang.model.element.Modifier;
 
@@ -48,7 +47,7 @@ public void execute(NodeContext context) {
     }
   }
 
-  private void addIfStrongValue(NodeContext context) {
+  private static void addIfStrongValue(NodeContext context) {
     var fieldSpec = context.isStrongKeys()
         ? FieldSpec.builder(kTypeVar, "key", Modifier.VOLATILE)
         : FieldSpec.builder(context.keyReferenceType(), "key", Modifier.VOLATILE);
@@ -61,12 +60,12 @@ private void addIfStrongValue(NodeContext context) {
         : context.keyReferenceType().rawType);
   }
 
-  private void addIfCollectedValue(NodeContext context) {
+  private static void addIfCollectedValue(NodeContext context) {
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder("getKeyReference")
         .addModifiers(context.publicFinalModifiers())
         .returns(Object.class)
         .addStatement("$1T valueRef = ($1T) $2L.get(this)",
-            context.valueReferenceType(), context.varHandleName("value"))
+            context.valueReferenceType(), varHandleName("value"))
         .addStatement("return valueRef.getKeyReference()")
         .build());
 
@@ -74,7 +73,7 @@ private void addIfCollectedValue(NodeContext context) {
         .addModifiers(context.publicFinalModifiers())
         .returns(kTypeVar)
         .addStatement("$1T valueRef = ($1T) $2L.get(this)",
-            context.valueReferenceType(), context.varHandleName("value"));
+            context.valueReferenceType(), varHandleName("value"));
     if (context.isStrongKeys()) {
       getKey.addStatement("return ($T) valueRef.getKeyReference()", kTypeVar);
     } else {
@@ -82,6 +81,6 @@ private void addIfCollectedValue(NodeContext context) {
       getKey.addStatement("return keyRef.get()");
     }
     context.nodeSubtype.addMethod(getKey.build());
-    context.suppressedWarnings.addAll(List.of("NullAway", "unchecked"));
+    context.suppressedWarnings.add("unchecked");
   }
 }
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddMaximum.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddMaximum.java
index 35fd7e0979..86838fb11d 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddMaximum.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddMaximum.java
@@ -39,7 +39,7 @@ public void execute(NodeContext context) {
     addWeight(context);
   }
 
-  private void addQueueFlag(NodeContext context) {
+  private static void addQueueFlag(NodeContext context) {
     context.nodeSubtype.addField(int.class, "queueType");
     context.nodeSubtype.addMethod(MethodSpec.methodBuilder("getQueueType")
         .addModifiers(context.publicFinalModifiers())
@@ -53,7 +53,7 @@ private void addQueueFlag(NodeContext context) {
         .build());
   }
 
-  private void addWeight(NodeContext context) {
+  private static void addWeight(NodeContext context) {
     if (!context.generateFeatures.contains(Feature.MAXIMUM_WEIGHT)) {
       return;
     }
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddSubtype.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddSubtype.java
index 921ea3d1c8..bc1eb546ec 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddSubtype.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddSubtype.java
@@ -39,7 +39,6 @@ public boolean applies(NodeContext context) {
 
   @Override
   public void execute(NodeContext context) {
-    context.suppressedWarnings.add("MissingOverride");
     context.nodeSubtype
         .addJavadoc(getJavaDoc(context))
         .addTypeVariable(kTypeVar)
@@ -56,7 +55,7 @@ public void execute(NodeContext context) {
     }
   }
 
-  private String getJavaDoc(NodeContext context) {
+  private static String getJavaDoc(NodeContext context) {
     var doc = new StringBuilder(200);
     doc.append("<em>WARNING: GENERATED CODE</em>\n\n"
         + "A cache entry that provides the following features:\n<ul>");
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddValue.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddValue.java
index f6ba070661..7b0f856d28 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddValue.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/AddValue.java
@@ -17,6 +17,7 @@
 
 import static com.github.benmanes.caffeine.cache.Specifications.vRefQueueType;
 import static com.github.benmanes.caffeine.cache.Specifications.vTypeVar;
+import static com.github.benmanes.caffeine.cache.node.NodeContext.varHandleName;
 
 import java.lang.ref.Reference;
 import java.util.Objects;
@@ -53,11 +54,10 @@ public void execute(NodeContext context) {
       context.addVarHandle("value", ClassName.get(Object.class));
     } else {
       context.addVarHandle("value", context.valueReferenceType().rawType);
-      context.suppressedWarnings.add("NullAway");
     }
   }
 
-  private FieldSpec newValueField(NodeContext context) {
+  private static FieldSpec newValueField(NodeContext context) {
     var fieldSpec = context.isStrongValues()
         ? FieldSpec.builder(vTypeVar, "value", Modifier.VOLATILE)
         : FieldSpec.builder(context.valueReferenceType(), "value", Modifier.VOLATILE);
@@ -65,11 +65,11 @@ private FieldSpec newValueField(NodeContext context) {
   }
 
   /** Creates the getValue method. */
-  private MethodSpec makeGetValue(NodeContext context) {
+  private static MethodSpec makeGetValue(NodeContext context) {
     var getter = MethodSpec.methodBuilder("getValue")
         .addModifiers(context.publicFinalModifiers())
         .returns(vTypeVar);
-    String handle = context.varHandleName("value");
+    String handle = varHandleName("value");
     if (context.valueStrength() == Strength.STRONG) {
       getter.addStatement("return ($T) $L.get(this)", vTypeVar, handle);
       return getter.build();
@@ -88,19 +88,19 @@ private MethodSpec makeGetValue(NodeContext context) {
   }
 
   /** Creates the setValue method. */
-  private MethodSpec makeSetValue(NodeContext context) {
+  private static MethodSpec makeSetValue(NodeContext context) {
     var setter = MethodSpec.methodBuilder("setValue")
         .addModifiers(context.publicFinalModifiers())
         .addParameter(vTypeVar, "value")
         .addParameter(vRefQueueType, "referenceQueue");
 
     if (context.isStrongValues()) {
-      setter.addStatement("$L.setRelease(this, $N)", context.varHandleName("value"), "value");
+      setter.addStatement("$L.setRelease(this, $N)", varHandleName("value"), "value");
     } else {
       setter.addStatement("$1T<V> ref = ($1T<V>) $2L.get(this)",
-          Reference.class, context.varHandleName("value"));
+          Reference.class, varHandleName("value"));
       setter.addStatement("$L.setRelease(this, new $T($L, $N, referenceQueue))",
-          context.varHandleName("value"), context.valueReferenceType(),
+          varHandleName("value"), context.valueReferenceType(),
           "getKeyReference()", "value");
       setter.addStatement("ref.clear()");
     }
@@ -108,7 +108,7 @@ private MethodSpec makeSetValue(NodeContext context) {
     return setter.build();
   }
 
-  private MethodSpec makeContainsValue(NodeContext context) {
+  private static MethodSpec makeContainsValue(NodeContext context) {
     var containsValue = MethodSpec.methodBuilder("containsValue")
         .addModifiers(context.publicFinalModifiers())
         .addParameter(Object.class, "value")
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/Finalize.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/Finalize.java
index 8f9e243892..d49dcd6773 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/Finalize.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/Finalize.java
@@ -52,7 +52,7 @@ public void execute(NodeContext context) {
     addStaticBlock(context);
   }
 
-  private void addStaticBlock(NodeContext context) {
+  private static void addStaticBlock(NodeContext context) {
     if (context.varHandles.isEmpty()) {
       return;
     }
diff --git a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/NodeContext.java b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/NodeContext.java
index 675cda7301..1697aa454a 100644
--- a/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/NodeContext.java
+++ b/caffeine/src/javaPoet/java/com/github/benmanes/caffeine/cache/node/NodeContext.java
@@ -153,27 +153,34 @@ public MethodSpec newGetter(Strength strength,
         .addModifiers(publicFinalModifiers())
         .returns(varType);
     if (strength == Strength.STRONG) {
-      if (visibility == Visibility.PLAIN) {
-        var template = String.format(US, "return (%s) $L.get(this)",
-            varType.isPrimitive() ? "$L" : "$T");
-        getter.addStatement(template, varType, varHandleName(varName));
-      } else if (visibility == Visibility.OPAQUE) {
-        var template = String.format(US, "return (%s) $L.getOpaque(this)",
-            varType.isPrimitive() ? "$L" : "$T");
-        getter.addStatement(template, varType, varHandleName(varName));
-      } else if (visibility == Visibility.VOLATILE) {
-        getter.addStatement("return $N", varName);
-      } else {
-        throw new IllegalArgumentException();
+      switch (visibility) {
+        case OPAQUE: {
+          var template = String.format(US, "return (%s) $L.getOpaque(this)",
+              varType.isPrimitive() ? "$L" : "$T");
+          getter.addStatement(template, varType, varHandleName(varName));
+          break;
+        }
+        case PLAIN: {
+          var template = String.format(US, "return (%s) $L.get(this)",
+              varType.isPrimitive() ? "$L" : "$T");
+          getter.addStatement(template, varType, varHandleName(varName));
+          break;
+        }
+        case VOLATILE:
+          getter.addStatement("return $N", varName);
+          break;
       }
     } else {
-      if (visibility == Visibility.PLAIN) {
-        getter.addStatement("return (($T<$T>) $L.get(this)).get()",
-            Reference.class, varType, varHandleName(varName));
-      } else if (visibility == Visibility.VOLATILE) {
-        getter.addStatement("return $N.get()", varName);
-      } else {
-        throw new IllegalArgumentException();
+      switch (visibility) {
+        case OPAQUE:
+          throw new IllegalArgumentException();
+        case PLAIN:
+          getter.addStatement("return (($T<$T>) $L.get(this)).get()",
+              Reference.class, varType, varHandleName(varName));
+          break;
+        case VOLATILE:
+          getter.addStatement("return $N.get()", varName);
+          break;
       }
     }
     return getter.build();
@@ -185,20 +192,22 @@ public MethodSpec newSetter(TypeName varType, String varName, Visibility visibil
     var setter = MethodSpec.methodBuilder(methodName)
         .addModifiers(publicFinalModifiers())
         .addParameter(varType, varName);
-    if (visibility == Visibility.PLAIN) {
-      setter.addStatement("$L.set(this, $N)", varHandleName(varName), varName);
-    } else if (visibility == Visibility.OPAQUE) {
-      setter.addStatement("$L.setOpaque(this, $N)", varHandleName(varName), varName);
-    } else if (visibility == Visibility.VOLATILE) {
-      setter.addStatement("this.$N = $N", varName, varName);
-    } else {
-      throw new IllegalArgumentException();
+    switch (visibility) {
+      case OPAQUE:
+        setter.addStatement("$L.setOpaque(this, $N)", varHandleName(varName), varName);
+        break;
+      case PLAIN:
+        setter.addStatement("$L.set(this, $N)", varHandleName(varName), varName);
+        break;
+      case VOLATILE:
+        setter.addStatement("this.$N = $N", varName, varName);
+        break;
     }
     return setter.build();
   }
 
   /** Returns the name of the VarHandle to this variable. */
-  public String varHandleName(String varName) {
+  public static String varHandleName(String varName) {
     return CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, varName);
   }
 
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/DelegationBenchmark.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/DelegationBenchmark.java
index df7e90fa96..669ca0f4e5 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/DelegationBenchmark.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/DelegationBenchmark.java
@@ -19,6 +19,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ThreadLocalRandom;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Scope;
 import org.openjdk.jmh.annotations.Setup;
@@ -66,8 +67,7 @@ public Integer delegate_get(ThreadState threadState) {
   static final class InheritMap extends ConcurrentHashMap<Integer, Integer> {
     private static final long serialVersionUID = 1L;
 
-    @Override
-    public Integer get(Object key) {
+    @Override public @Nullable Integer get(Object key) {
       Integer value = super.get(key);
       return (value == null) ? null : (value - 1);
     }
@@ -76,14 +76,11 @@ public Integer get(Object key) {
   static final class DelegateMap extends ForwardingMap<Integer, Integer> {
     final Map<Integer, Integer> delegate = new ConcurrentHashMap<>();
 
-    @Override
-    public Integer get(Object key) {
+    @Override public @Nullable Integer get(Object key) {
       Integer value = delegate.get(key);
       return (value == null) ? null : (value - 1);
     }
-
-    @Override
-    protected Map<Integer, Integer> delegate() {
+    @Override protected Map<Integer, Integer> delegate() {
       return delegate;
     }
   }
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/BuilderBenchmark.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/BuilderBenchmark.java
index 82b7272466..4a44e33ccc 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/BuilderBenchmark.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/BuilderBenchmark.java
@@ -38,32 +38,12 @@
  */
 @State(Scope.Benchmark)
 public class BuilderBenchmark {
-  @Param
-  BuilderType type;
-
+  @Param BuilderType type;
   Supplier<?> builder;
 
   @Setup
   public void setup() {
-    if (type == BuilderType.Unbound_Caffeine) {
-      builder = Caffeine.newBuilder()::build;
-    } else if (type == BuilderType.Bounded_Caffeine) {
-      builder = Caffeine.newBuilder()
-          .expireAfterAccess(Duration.ofMinutes(1))
-          .maximumSize(100)
-          ::build;
-    } else if (type == BuilderType.Unbound_Guava) {
-      builder = CacheBuilder.newBuilder()::build;
-    } else if (type == BuilderType.Bounded_Guava) {
-      builder = CacheBuilder.newBuilder()
-          .expireAfterAccess(Duration.ofMinutes(1))
-          .maximumSize(100)
-          ::build;
-    } else if (type == BuilderType.ConcurrentHashMap) {
-      builder = ConcurrentHashMap::new;
-    } else {
-      throw new IllegalStateException();
-    }
+    builder = type.builder();
   }
 
   @Benchmark
@@ -71,9 +51,32 @@ public void build(Blackhole blackhole) {
     blackhole.consume(builder.get());
   }
 
+  @SuppressWarnings("MemberName")
   public enum BuilderType {
     Unbound_Caffeine, Bounded_Caffeine,
     Unbound_Guava, Bounded_Guava,
     ConcurrentHashMap;
+
+    Supplier<?> builder() {
+      switch (this) {
+        case Unbound_Caffeine:
+          return Caffeine.newBuilder()::build;
+        case Bounded_Caffeine:
+          return Caffeine.newBuilder()
+              .expireAfterAccess(Duration.ofMinutes(1))
+              .maximumSize(100)
+              ::build;
+        case Unbound_Guava:
+          return CacheBuilder.newBuilder()::build;
+        case Bounded_Guava:
+          return CacheBuilder.newBuilder()
+              .expireAfterAccess(Duration.ofMinutes(1))
+              .maximumSize(100)
+              ::build;
+        case ConcurrentHashMap:
+          return ConcurrentHashMap::new;
+      }
+      throw new IllegalStateException();
+    }
   }
 }
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/CacheType.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/CacheType.java
index 7243e4da02..f2b84a17dd 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/CacheType.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/CacheType.java
@@ -155,7 +155,7 @@ public enum CacheType {
   },
   LinkedHashMap_Lru {
     @Override public <K, V> BasicCache<K, V> create(int maximumSize) {
-      return new LinkedHashMapCache<>(maximumSize, /* accessOrder */ true);
+      return new LinkedHashMapCache<>(maximumSize, /* accessOrder= */ true);
     }
   },
   TCache_Lfu {
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/ComputeBenchmark.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/ComputeBenchmark.java
index 04cc53ff26..99c4910997 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/ComputeBenchmark.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/ComputeBenchmark.java
@@ -18,7 +18,6 @@
 import java.util.Arrays;
 import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -93,7 +92,7 @@ public Boolean compute_spread(ThreadState threadState) {
   }
 
   private void setupConcurrentHashMap() {
-    ConcurrentMap<Integer, Boolean> map = new ConcurrentHashMap<>();
+    var map = new ConcurrentHashMap<Integer, Boolean>();
     benchmarkFunction = key -> map.computeIfAbsent(key, mappingFunction);
   }
 
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/MemoryBenchmark.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/MemoryBenchmark.java
index bf7492ce2c..33567f2d8d 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/MemoryBenchmark.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/MemoryBenchmark.java
@@ -44,7 +44,8 @@
  *
  * @author ben.manes@gmail.com (Ben Manes)
  */
-@SuppressWarnings({"LexicographicalAnnotationAttributeListing", "PMD.MethodNamingConventions"})
+@SuppressWarnings({"LexicographicalAnnotationAttributeListing",
+  "PMD.MethodNamingConventions", "SystemOut"})
 public final class MemoryBenchmark {
   // The number of entries added to minimize skew due to non-entry factors
   static final int FUZZY_SIZE = 25_000;
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/TimerWheelBenchmark.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/TimerWheelBenchmark.java
index bc0f6192bf..62f77e930a 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/TimerWheelBenchmark.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/TimerWheelBenchmark.java
@@ -156,7 +156,7 @@ static final class MockCache extends BoundedLocalCache<Integer, Integer> {
 
     @SuppressWarnings({"rawtypes", "unchecked"})
     MockCache() {
-      super((Caffeine) Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false);
+      super((Caffeine) Caffeine.newBuilder(), /* cacheLoader= */ null, /* isAsync= */ false);
     }
 
     @Override
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/impl/HazelcastCache.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/impl/HazelcastCache.java
index 371f43eb9d..9084e389ed 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/impl/HazelcastCache.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/impl/HazelcastCache.java
@@ -44,7 +44,7 @@ public HazelcastCache(int maximumSize, EvictionPolicy policy) {
             .setEvictionPolicy(policy)
             .setSize(maximumSize));
     cache = new DefaultNearCache<>("simulation", config, DummySerializationService.INSTANCE,
-        /* TaskScheduler */ null, getClass().getClassLoader(), /* HazelcastProperties */ null);
+        /* scheduler= */ null, getClass().getClassLoader(), /* properties= */ null);
     cache.initialize();
   }
 
@@ -55,7 +55,7 @@ public V get(K key) {
 
   @Override
   public void put(K key, V value) {
-    cache.put(key, /* keyData */ null, value, /* valueDate */ null);
+    cache.put(key, /* keyData= */ null, value, /* valueDate= */ null);
   }
 
   @Override
@@ -88,7 +88,7 @@ enum DummySerializationService implements SerializationService {
       return (T) data;
     }
     @Override public ManagedContext getManagedContext() {
-      return null;
+      throw new UnsupportedOperationException();
     }
     @Override public <B extends Data> B trimSchema(Data data) {
       return (B) data;
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/sketch/CountMinSketch.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/sketch/CountMinSketch.java
index 4d9ef1d210..b2990fb789 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/sketch/CountMinSketch.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/sketch/CountMinSketch.java
@@ -82,8 +82,7 @@ public CountMinSketch(@NonNegative long maximumSize) {
    * @return the estimated number of occurrences of the element; possibly zero but never negative
    */
   @Override
-  @NonNegative
-  public int frequency(E e) {
+  public @NonNegative int frequency(E e) {
     int hash = spread(e.hashCode());
     int start = (hash & 3) << 2;
     int frequency = Integer.MAX_VALUE;
diff --git a/caffeine/src/jmh/java/com/github/benmanes/caffeine/profiler/ProfilerHook.java b/caffeine/src/jmh/java/com/github/benmanes/caffeine/profiler/ProfilerHook.java
index 72a15dc99b..2031ff6938 100644
--- a/caffeine/src/jmh/java/com/github/benmanes/caffeine/profiler/ProfilerHook.java
+++ b/caffeine/src/jmh/java/com/github/benmanes/caffeine/profiler/ProfilerHook.java
@@ -46,7 +46,7 @@ public final void run() {
 
   protected abstract void profile();
 
-  @SuppressWarnings("FutureReturnValueIgnored")
+  @SuppressWarnings({"FutureReturnValueIgnored", "SystemOut"})
   private void scheduleStatusTask() {
     Stopwatch stopwatch = Stopwatch.createStarted();
     Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/AbstractLinkedDeque.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/AbstractLinkedDeque.java
index 8d09f84d68..ee2b250633 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/AbstractLinkedDeque.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/AbstractLinkedDeque.java
@@ -22,6 +22,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * This class provides a skeletal implementation of the {@link LinkedDeque} interface to minimize
  * the effort required to implement this interface.
@@ -63,8 +65,8 @@ abstract class AbstractLinkedDeque<E> extends AbstractCollection<E> implements L
    *
    * @param e the unlinked element
    */
-  void linkFirst(final E e) {
-    final E f = first;
+  void linkFirst(E e) {
+    E f = first;
     first = e;
 
     if (f == null) {
@@ -81,8 +83,8 @@ void linkFirst(final E e) {
    *
    * @param e the unlinked element
    */
-  void linkLast(final E e) {
-    final E l = last;
+  void linkLast(E e) {
+    E l = last;
     last = e;
 
     if (l == null) {
@@ -97,8 +99,8 @@ void linkLast(final E e) {
   /** Unlinks the non-null first element. */
   @SuppressWarnings("NullAway")
   E unlinkFirst() {
-    final E f = first;
-    final E next = getNext(f);
+    E f = first;
+    E next = getNext(f);
     setNext(f, null);
 
     first = next;
@@ -114,8 +116,8 @@ E unlinkFirst() {
   /** Unlinks the non-null last element. */
   @SuppressWarnings("NullAway")
   E unlinkLast() {
-    final E l = last;
-    final E prev = getPrevious(l);
+    E l = last;
+    E prev = getPrevious(l);
     setPrevious(l, null);
     last = prev;
     if (prev == null) {
@@ -129,8 +131,8 @@ E unlinkLast() {
 
   /** Unlinks the non-null element. */
   void unlink(E e) {
-    final E prev = getPrevious(e);
-    final E next = getNext(e);
+    E prev = getPrevious(e);
+    E next = getNext(e);
 
     if (prev == null) {
       first = next;
@@ -166,7 +168,7 @@ void checkNotEmpty() {
    */
   @Override
   public int size() {
-    int size = 0;
+    @Var int size = 0;
     for (E e = first; e != null; e = getNext(e)) {
       size++;
     }
@@ -175,7 +177,7 @@ public int size() {
 
   @Override
   public void clear() {
-    E e = first;
+    @Var E e = first;
     while (e != null) {
       E next = getNext(e);
       setPrevious(e, null);
@@ -340,7 +342,7 @@ public boolean removeLastOccurrence(Object o) {
 
   @Override
   public boolean removeAll(Collection<?> c) {
-    boolean modified = false;
+    @Var boolean modified = false;
     for (Object o : c) {
       modified |= remove(o);
     }
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Async.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Async.java
index 459df30cda..c4f7e81aee 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Async.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Async.java
@@ -49,12 +49,12 @@ static boolean isReady(@Nullable CompletableFuture<?> future) {
 
   /** Returns the current value or null if either not done or failed. */
   @SuppressWarnings("NullAway")
-  static @Nullable <V> V getIfReady(@Nullable CompletableFuture<V> future) {
+  static <V> @Nullable V getIfReady(@Nullable CompletableFuture<V> future) {
     return isReady(future) ? future.join() : null;
   }
 
   /** Returns the value when completed successfully or null if failed. */
-  static @Nullable <V> V getWhenSuccessful(@Nullable CompletableFuture<V> future) {
+  static <V> @Nullable V getWhenSuccessful(@Nullable CompletableFuture<V> future) {
     try {
       return (future == null) ? null : future.join();
     } catch (CancellationException | CompletionException e) {
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedBuffer.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedBuffer.java
index df713aee50..6929b104b4 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedBuffer.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedBuffer.java
@@ -19,6 +19,8 @@
 import java.lang.invoke.VarHandle;
 import java.util.function.Consumer;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A striped, non-blocking, bounded buffer.
  *
@@ -66,6 +68,7 @@ public RingBuffer(E e) {
     }
 
     @Override
+    @SuppressWarnings("Varifier")
     public int offer(E e) {
       long head = readCounter;
       long tail = writeCounterOpaque();
@@ -82,8 +85,9 @@ public int offer(E e) {
     }
 
     @Override
+    @SuppressWarnings("Varifier")
     public void drainTo(Consumer<E> consumer) {
-      long head = readCounter;
+      @Var long head = readCounter;
       long tail = writeCounterOpaque();
       long size = (tail - head);
       if (size == 0) {
@@ -92,7 +96,7 @@ public void drainTo(Consumer<E> consumer) {
       do {
         int index = (int) (head & MASK);
         @SuppressWarnings("unchecked")
-        E e = (E) BUFFER.getAcquire(buffer, index);
+        var e = (E) BUFFER.getAcquire(buffer, index);
         if (e == null) {
           // not published yet
           break;
@@ -117,8 +121,11 @@ public long writes() {
 }
 
 /** The namespace for field padding through inheritance. */
+@SuppressWarnings("MultiVariableDeclaration")
 final class BBHeader {
 
+  private BBHeader() {}
+
   @SuppressWarnings("PMD.AbstractClassWithoutAbstractMethod")
   abstract static class PadReadCounter {
     byte p000, p001, p002, p003, p004, p005, p006, p007;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java
index 6c8632432b..57b6e7f154 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java
@@ -91,6 +91,7 @@
 import com.github.benmanes.caffeine.cache.References.InternalReference;
 import com.github.benmanes.caffeine.cache.stats.StatsCounter;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 import com.google.errorprone.annotations.concurrent.GuardedBy;
 
 /**
@@ -254,7 +255,7 @@ abstract class BoundedLocalCache<K, V> extends BLCHeader.DrainStatusRef
   @Nullable Set<K> keySet;
   @Nullable Collection<V> values;
   @Nullable Set<Entry<K, V>> entrySet;
-  @Nullable volatile ConcurrentMap<Object, CompletableFuture<?>> refreshes;
+  volatile @Nullable ConcurrentMap<Object, CompletableFuture<?>> refreshes;
 
   /** Creates an instance based on the builder's configuration. */
   @SuppressWarnings("GuardedBy")
@@ -354,7 +355,7 @@ public final Executor executor() {
   @Override
   @SuppressWarnings("NullAway")
   public ConcurrentMap<Object, CompletableFuture<?>> refreshes() {
-    var pending = refreshes;
+    @Var var pending = refreshes;
     if (pending == null) {
       pending = new ConcurrentHashMap<>();
       if (!REFRESHES.compareAndSet(this, null, pending)) {
@@ -676,6 +677,7 @@ protected void setAdjustment(long amount) {
    * to eagerly evicts entries until the cache shrinks to the appropriate size.
    */
   @GuardedBy("evictionLock")
+  @SuppressWarnings("Varifier")
   void setMaximumSize(long maximum) {
     requireArgument(maximum >= 0, "maximum must not be negative");
     if (maximum == maximum()) {
@@ -718,8 +720,8 @@ void evictEntries() {
    */
   @GuardedBy("evictionLock")
   @Nullable Node<K, V> evictFromWindow() {
-    Node<K, V> first = null;
-    Node<K, V> node = accessOrderWindowDeque().peekFirst();
+    @Var Node<K, V> first = null;
+    @Var Node<K, V> node = accessOrderWindowDeque().peekFirst();
     while (windowWeightedSize() > windowMaximum()) {
       // The pending operations will adjust the size to reflect the correct weight
       if (node == null) {
@@ -761,10 +763,10 @@ void evictEntries() {
    * @param candidate the first candidate promoted into the probation space
    */
   @GuardedBy("evictionLock")
-  void evictFromMain(@Nullable Node<K, V> candidate) {
-    int victimQueue = PROBATION;
-    int candidateQueue = PROBATION;
-    Node<K, V> victim = accessOrderProbationDeque().peekFirst();
+  void evictFromMain(@Var @Nullable Node<K, V> candidate) {
+    @Var int victimQueue = PROBATION;
+    @Var int candidateQueue = PROBATION;
+    @Var Node<K, V> victim = accessOrderProbationDeque().peekFirst();
     while (weightedSize() > maximum()) {
       // Search the admission window for additional candidates
       if ((candidate == null) && (candidateQueue == PROBATION)) {
@@ -922,16 +924,16 @@ void expireAfterAccessEntries(long now) {
       return;
     }
 
-    expireAfterAccessEntries(accessOrderWindowDeque(), now);
+    expireAfterAccessEntries(now, accessOrderWindowDeque());
     if (evicts()) {
-      expireAfterAccessEntries(accessOrderProbationDeque(), now);
-      expireAfterAccessEntries(accessOrderProtectedDeque(), now);
+      expireAfterAccessEntries(now, accessOrderProbationDeque());
+      expireAfterAccessEntries(now, accessOrderProtectedDeque());
     }
   }
 
   /** Expires entries in an access-order queue. */
   @GuardedBy("evictionLock")
-  void expireAfterAccessEntries(AccessOrderDeque<Node<K, V>> accessOrderDeque, long now) {
+  void expireAfterAccessEntries(long now, AccessOrderDeque<Node<K, V>> accessOrderDeque) {
     long duration = expiresAfterAccessNanos();
     for (;;) {
       Node<K, V> node = accessOrderDeque.peekFirst();
@@ -969,9 +971,9 @@ void expireVariableEntries(long now) {
   /** Returns the duration until the next item expires, or {@link Long#MAX_VALUE} if none. */
   @GuardedBy("evictionLock")
   long getExpirationDelay(long now) {
-    long delay = Long.MAX_VALUE;
+    @Var long delay = Long.MAX_VALUE;
     if (expiresAfterAccess()) {
-      Node<K, V> node = accessOrderWindowDeque().peekFirst();
+      @Var Node<K, V> node = accessOrderWindowDeque().peekFirst();
       if (node != null) {
         delay = Math.min(delay, expiresAfterAccessNanos() - (now - node.getAccessTime()));
       }
@@ -1023,11 +1025,11 @@ boolean hasExpired(Node<K, V> node, long now) {
   boolean evictEntry(Node<K, V> node, RemovalCause cause, long now) {
     K key = node.getKey();
     @SuppressWarnings("unchecked")
-    V[] value = (V[]) new Object[1];
-    boolean[] removed = new boolean[1];
-    boolean[] resurrect = new boolean[1];
-    Object keyReference = node.getKeyReference();
-    RemovalCause[] actualCause = new RemovalCause[1];
+    var value = (V[]) new Object[1];
+    var removed = new boolean[1];
+    var resurrect = new boolean[1];
+    var actualCause = new RemovalCause[1];
+    var keyReference = node.getKeyReference();
 
     data.computeIfPresent(keyReference, (k, n) -> {
       if (n != node) {
@@ -1046,7 +1048,7 @@ boolean evictEntry(Node<K, V> node, RemovalCause cause, long now) {
         }
 
         if (actualCause[0] == RemovalCause.EXPIRED) {
-          boolean expired = false;
+          @Var boolean expired = false;
           if (expiresAfterAccess()) {
             expired |= ((now - n.getAccessTime()) >= expiresAfterAccessNanos());
           }
@@ -1173,14 +1175,14 @@ void increaseWindow() {
       return;
     }
 
-    long quota = Math.min(adjustment(), mainProtectedMaximum());
+    @Var long quota = Math.min(adjustment(), mainProtectedMaximum());
     setMainProtectedMaximum(mainProtectedMaximum() - quota);
     setWindowMaximum(windowMaximum() + quota);
     demoteFromMainProtected();
 
     for (int i = 0; i < QUEUE_TRANSFER_THRESHOLD; i++) {
-      Node<K, V> candidate = accessOrderProbationDeque().peekFirst();
-      boolean probation = true;
+      @Var Node<K, V> candidate = accessOrderProbationDeque().peekFirst();
+      @Var boolean probation = true;
       if ((candidate == null) || (quota < candidate.getPolicyWeight())) {
         candidate = accessOrderProtectedDeque().peekFirst();
         probation = false;
@@ -1218,7 +1220,7 @@ void decreaseWindow() {
       return;
     }
 
-    long quota = Math.min(-adjustment(), Math.max(0, windowMaximum() - 1));
+    @Var long quota = Math.min(-adjustment(), Math.max(0, windowMaximum() - 1));
     setMainProtectedMaximum(mainProtectedMaximum() + quota);
     setWindowMaximum(windowMaximum() - quota);
 
@@ -1249,7 +1251,7 @@ void decreaseWindow() {
   @GuardedBy("evictionLock")
   void demoteFromMainProtected() {
     long mainProtectedMaximum = mainProtectedMaximum();
-    long mainProtectedWeightedSize = mainProtectedWeightedSize();
+    @Var long mainProtectedWeightedSize = mainProtectedWeightedSize();
     if (mainProtectedWeightedSize <= mainProtectedMaximum) {
       return;
     }
@@ -1327,7 +1329,7 @@ boolean skipReadBuffer() {
             startTime[0] = statsTicker().read();
             if (isAsync) {
               @SuppressWarnings("unchecked")
-              CompletableFuture<V> future = (CompletableFuture<V>) oldValue;
+              var future = (CompletableFuture<V>) oldValue;
               if (Async.isReady(future)) {
                 @SuppressWarnings("NullAway")
                 var refresh = cacheLoader.asyncReload(key, future.join(), executor);
@@ -1395,7 +1397,7 @@ boolean skipReadBuffer() {
           // Otherwise, a write invalidated the refresh so discard it and notify the listener
           cause[0] = RemovalCause.REPLACED;
           return currentValue;
-        }, expiry(), /* recordLoad */ false, /* recordLoadFailure */ true);
+        }, expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ true);
 
         if (cause[0] != null) {
           notifyRemoval(key, value, cause[0]);
@@ -1557,9 +1559,9 @@ void afterWrite(Runnable task) {
 
   /** Acquires the eviction lock. */
   void lock() {
-    long remainingNanos = WARN_AFTER_LOCK_WAIT_NANOS;
+    @Var long remainingNanos = WARN_AFTER_LOCK_WAIT_NANOS;
     long end = System.nanoTime() + remainingNanos;
-    boolean interrupted = false;
+    @Var boolean interrupted = false;
     try {
       for (;;) {
         try {
@@ -1591,7 +1593,7 @@ void lock() {
    * execution is triggered by the next operation.
    */
   void scheduleAfterWrite() {
-    int drainStatus = drainStatusOpaque();
+    @Var int drainStatus = drainStatusOpaque();
     for (;;) {
       switch (drainStatus) {
         case IDLE:
@@ -1736,7 +1738,7 @@ void drainKeyReferences() {
     if (!collectKeys()) {
       return;
     }
-    Reference<? extends K> keyRef;
+    @Var Reference<? extends K> keyRef;
     while ((keyRef = keyReferenceQueue().poll()) != null) {
       Node<K, V> node = data.get(keyRef);
       if (node != null) {
@@ -1751,10 +1753,10 @@ void drainValueReferences() {
     if (!collectValues()) {
       return;
     }
-    Reference<? extends V> valueRef;
+    @Var Reference<? extends V> valueRef;
     while ((valueRef = valueReferenceQueue().poll()) != null) {
       @SuppressWarnings("unchecked")
-      InternalReference<V> ref = (InternalReference<V>) valueRef;
+      var ref = (InternalReference<V>) valueRef;
       Node<K, V> node = data.get(ref.getKeyReference());
       if ((node != null) && (valueRef == node.getValueReference())) {
         evictEntry(node, RemovalCause.COLLECTED, 0L);
@@ -2051,7 +2053,7 @@ public void clear() {
       readBuffer.drainTo(e -> {});
 
       // Apply all pending writes
-      Runnable task;
+      @Var Runnable task;
       while ((task = writeBuffer.poll()) != null) {
         task.run();
       }
@@ -2074,7 +2076,7 @@ public void clear() {
     }
 
     // Remove any stragglers if released early to more aggressively flush incoming writes
-    boolean cleanUp = false;
+    @Var boolean cleanUp = false;
     for (var node : entries) {
       var key = node.getKey();
       if (key == null) {
@@ -2093,9 +2095,9 @@ public void clear() {
   void removeNode(Node<K, V> node, long now) {
     K key = node.getKey();
     @SuppressWarnings("unchecked")
-    V[] value = (V[]) new Object[1];
-    RemovalCause[] cause = new RemovalCause[1];
-    Object keyReference = node.getKeyReference();
+    var value = (V[]) new Object[1];
+    var cause = new RemovalCause[1];
+    var keyReference = node.getKeyReference();
 
     data.computeIfPresent(keyReference, (k, n) -> {
       if (n != node) {
@@ -2170,7 +2172,7 @@ public boolean containsValue(Object value) {
 
   @Override
   public @Nullable V get(Object key) {
-    return getIfPresent(key, /* recordStats */ false);
+    return getIfPresent(key, /* recordStats= */ false);
   }
 
   @Override
@@ -2198,7 +2200,7 @@ public boolean containsValue(Object value) {
 
     if (!isComputingAsync(node)) {
       @SuppressWarnings("unchecked")
-      K castedKey = (K) key;
+      var castedKey = (K) key;
       setAccessTime(node, now);
       tryExpireAfterRead(node, castedKey, value, expiry(), now);
     }
@@ -2233,7 +2235,7 @@ public boolean containsValue(Object value) {
       }
       return null;
     }
-    afterRead(node, /* now */ 0L, /* recordStats */ false);
+    afterRead(node, /* now= */ 0L, /* recordHit= */ false);
     return node.getKey();
   }
 
@@ -2257,7 +2259,7 @@ public Map<K, V> getAllPresent(Iterable<? extends K> keys) {
           tryExpireAfterRead(node, entry.getKey(), value, expiry(), now);
           setAccessTime(node, now);
         }
-        V refreshed = afterRead(node, now, /* recordHit */ false);
+        V refreshed = afterRead(node, now, /* recordHit= */ false);
         entry.setValue((refreshed == null) ? value : refreshed);
       }
     }
@@ -2274,12 +2276,12 @@ public void putAll(Map<? extends K, ? extends V> map) {
 
   @Override
   public @Nullable V put(K key, V value) {
-    return put(key, value, expiry(), /* onlyIfAbsent */ false);
+    return put(key, value, expiry(), /* onlyIfAbsent= */ false);
   }
 
   @Override
   public @Nullable V putIfAbsent(K key, V value) {
-    return put(key, value, expiry(), /* onlyIfAbsent */ true);
+    return put(key, value, expiry(), /* onlyIfAbsent= */ true);
   }
 
   /**
@@ -2296,12 +2298,12 @@ public void putAll(Map<? extends K, ? extends V> map) {
     requireNonNull(key);
     requireNonNull(value);
 
-    Node<K, V> node = null;
+    @Var Node<K, V> node = null;
     long now = expirationTicker().read();
     int newWeight = weigher.weigh(key, value);
     Object lookupKey = nodeFactory.newLookupKey(key);
     for (int attempts = 1; ; attempts++) {
-      Node<K, V> prior = data.get(lookupKey);
+      @Var Node<K, V> prior = data.get(lookupKey);
       if (prior == null) {
         if (node == null) {
           node = nodeFactory.newNode(key, keyReferenceQueue(),
@@ -2320,7 +2322,7 @@ public void putAll(Map<? extends K, ? extends V> map) {
               tryExpireAfterRead(prior, key, currentValue, expiry(), now);
               setAccessTime(prior, now);
             }
-            afterRead(prior, now, /* recordHit */ false);
+            afterRead(prior, now, /* recordHit= */ false);
             return currentValue;
           }
         }
@@ -2332,7 +2334,7 @@ public void putAll(Map<? extends K, ? extends V> map) {
             tryExpireAfterRead(prior, key, currentValue, expiry(), now);
             setAccessTime(prior, now);
           }
-          afterRead(prior, now, /* recordHit */ false);
+          afterRead(prior, now, /* recordHit= */ false);
           return currentValue;
         }
       }
@@ -2364,9 +2366,9 @@ public void putAll(Map<? extends K, ? extends V> map) {
       V oldValue;
       long varTime;
       int oldWeight;
-      boolean expired = false;
-      boolean mayUpdate = true;
-      boolean exceedsTolerance = false;
+      @Var boolean expired = false;
+      @Var boolean mayUpdate = true;
+      @Var boolean exceedsTolerance = false;
       synchronized (prior) {
         if (!prior.isAlive()) {
           continue;
@@ -2421,7 +2423,7 @@ public void putAll(Map<? extends K, ? extends V> map) {
         if (mayUpdate) {
           setWriteTime(prior, now);
         }
-        afterRead(prior, now, /* recordHit */ false);
+        afterRead(prior, now, /* recordHit= */ false);
       }
 
       return expired ? null : oldValue;
@@ -2431,11 +2433,11 @@ public void putAll(Map<? extends K, ? extends V> map) {
   @Override
   public @Nullable V remove(Object key) {
     @SuppressWarnings("unchecked")
-    K castKey = (K) key;
+    var castKey = (K) key;
     @SuppressWarnings({"rawtypes", "unchecked"})
     Node<K, V>[] node = new Node[1];
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     RemovalCause[] cause = new RemovalCause[1];
     Object lookupKey = nodeFactory.newLookupKey(key);
 
@@ -2477,9 +2479,9 @@ public boolean remove(Object key, Object value) {
     @SuppressWarnings({"rawtypes", "unchecked"})
     Node<K, V>[] removed = new Node[1];
     @SuppressWarnings("unchecked")
-    K[] oldKey = (K[]) new Object[1];
+    var oldKey = (K[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     RemovalCause[] cause = new RemovalCause[1];
     Object lookupKey = nodeFactory.newLookupKey(key);
 
@@ -2521,12 +2523,12 @@ public boolean remove(Object key, Object value) {
     requireNonNull(key);
     requireNonNull(value);
 
-    int[] oldWeight = new int[1];
+    long[] now = new long[1];
+    var oldWeight = new int[1];
     @SuppressWarnings("unchecked")
-    K[] nodeKey = (K[]) new Object[1];
+    var nodeKey = (K[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
-    long[] now = new long[1];
+    var oldValue = (V[]) new Object[1];
     int weight = weigher.weigh(key, value);
     Node<K, V> node = data.computeIfPresent(nodeFactory.newLookupKey(key), (k, n) -> {
       synchronized (n) {
@@ -2560,7 +2562,7 @@ public boolean remove(Object key, Object value) {
     if (expiresAfterWrite() || (weightedDifference != 0)) {
       afterWrite(new UpdateTask(node, weightedDifference));
     } else {
-      afterRead(node, now[0], /* recordHit */ false);
+      afterRead(node, now[0], /* recordHit= */ false);
     }
 
     notifyOnReplace(nodeKey[0], oldValue[0], value);
@@ -2569,7 +2571,7 @@ public boolean remove(Object key, Object value) {
 
   @Override
   public boolean replace(K key, V oldValue, V newValue) {
-    return replace(key, oldValue, newValue, /* shouldDiscardRefresh */ true);
+    return replace(key, oldValue, newValue, /* shouldDiscardRefresh= */ true);
   }
 
   @Override
@@ -2581,9 +2583,9 @@ public boolean replace(K key, V oldValue, V newValue, boolean shouldDiscardRefre
     int weight = weigher.weigh(key, newValue);
     boolean[] replaced = new boolean[1];
     @SuppressWarnings("unchecked")
-    K[] nodeKey = (K[]) new Object[1];
+    var nodeKey = (K[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] prevValue = (V[]) new Object[1];
+    var prevValue = (V[]) new Object[1];
     int[] oldWeight = new int[1];
     long[] now = new long[1];
     Node<K, V> node = data.computeIfPresent(nodeFactory.newLookupKey(key), (k, n) -> {
@@ -2621,7 +2623,7 @@ public boolean replace(K key, V oldValue, V newValue, boolean shouldDiscardRefre
     if (expiresAfterWrite() || (weightedDifference != 0)) {
       afterWrite(new UpdateTask(node, weightedDifference));
     } else {
-      afterRead(node, now[0], /* recordHit */ false);
+      afterRead(node, now[0], /* recordHit= */ false);
     }
 
     notifyOnReplace(nodeKey[0], prevValue[0], newValue);
@@ -2637,12 +2639,12 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
     for (K key : keySet()) {
       long[] now = { expirationTicker().read() };
       Object lookupKey = nodeFactory.newLookupKey(key);
-      remap(key, lookupKey, remappingFunction, expiry(), now, /* computeIfAbsent */ false);
+      remap(key, lookupKey, remappingFunction, expiry(), now, /* computeIfAbsent= */ false);
     }
   }
 
   @Override
-  public @Nullable V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction,
+  public @Nullable V computeIfAbsent(K key, @Var Function<? super K, ? extends V> mappingFunction,
       boolean recordStats, boolean recordLoad) {
     requireNonNull(key);
     requireNonNull(mappingFunction);
@@ -2657,7 +2659,7 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
           tryExpireAfterRead(node, key, value, expiry(), now);
           setAccessTime(node, now);
         }
-        var refreshed = afterRead(node, now, /* recordHit */ recordStats);
+        var refreshed = afterRead(node, now, /* recordHit= */ recordStats);
         return (refreshed == null) ? value : refreshed;
       }
     }
@@ -2672,11 +2674,11 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
   @Nullable V doComputeIfAbsent(K key, Object keyRef,
       Function<? super K, ? extends V> mappingFunction, long[/* 1 */] now, boolean recordStats) {
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] newValue = (V[]) new Object[1];
+    var newValue = (V[]) new Object[1];
     @SuppressWarnings("unchecked")
-    K[] nodeKey = (K[]) new Object[1];
+    var nodeKey = (K[]) new Object[1];
     @SuppressWarnings({"rawtypes", "unchecked"})
     Node<K, V>[] removed = new Node[1];
 
@@ -2690,10 +2692,10 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
         }
         now[0] = expirationTicker().read();
         weight[1] = weigher.weigh(key, newValue[0]);
-        n = nodeFactory.newNode(key, keyReferenceQueue(),
+        var created = nodeFactory.newNode(key, keyReferenceQueue(),
             newValue[0], valueReferenceQueue(), weight[1], now[0]);
-        setVariableTime(n, expireAfterCreate(key, newValue[0], expiry(), now[0]));
-        return n;
+        setVariableTime(created, expireAfterCreate(key, newValue[0], expiry(), now[0]));
+        return created;
       }
 
       synchronized (n) {
@@ -2751,7 +2753,7 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
         setAccessTime(node, now[0]);
       }
 
-      afterRead(node, now[0], /* recordHit */ recordStats);
+      afterRead(node, now[0], /* recordHit= */ recordStats);
       return oldValue[0];
     }
     if ((oldValue[0] == null) && (cause[0] == null)) {
@@ -2782,9 +2784,9 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
     }
 
     BiFunction<? super K, ? super V, ? extends V> statsAwareRemappingFunction =
-        statsAware(remappingFunction, /* recordLoad */ true, /* recordLoadFailure */ true);
+        statsAware(remappingFunction, /* recordLoad= */ true, /* recordLoadFailure= */ true);
     return remap(key, lookupKey, statsAwareRemappingFunction,
-        expiry(), new long[] { now }, /* computeIfAbsent */ false);
+        expiry(), new long[] { now }, /* computeIfAbsent= */ false);
   }
 
   @Override
@@ -2800,7 +2802,7 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
     BiFunction<? super K, ? super V, ? extends V> statsAwareRemappingFunction =
         statsAware(remappingFunction, recordLoad, recordLoadFailure);
     return remap(key, keyRef, statsAwareRemappingFunction,
-        expiry, now, /* computeIfAbsent */ true);
+        expiry, now, /* computeIfAbsent= */ true);
   }
 
   @Override
@@ -2814,7 +2816,7 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
     Object keyRef = nodeFactory.newReferenceKey(key, keyReferenceQueue());
     BiFunction<? super K, ? super V, ? extends V> mergeFunction = (k, oldValue) ->
         (oldValue == null) ? value : statsAware(remappingFunction).apply(oldValue, value);
-    return remap(key, keyRef, mergeFunction, expiry(), now, /* computeIfAbsent */ true);
+    return remap(key, keyRef, mergeFunction, expiry(), now, /* computeIfAbsent= */ true);
   }
 
   /**
@@ -2838,16 +2840,16 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
       BiFunction<? super K, ? super V, ? extends V> remappingFunction,
       Expiry<? super K, ? super V> expiry, long[/* 1 */] now, boolean computeIfAbsent) {
     @SuppressWarnings("unchecked")
-    K[] nodeKey = (K[]) new Object[1];
+    var nodeKey = (K[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     @SuppressWarnings("unchecked")
-    V[] newValue = (V[]) new Object[1];
+    var newValue = (V[]) new Object[1];
     @SuppressWarnings({"rawtypes", "unchecked"})
     Node<K, V>[] removed = new Node[1];
 
-    int[] weight = new int[2]; // old, new
-    RemovalCause[] cause = new RemovalCause[1];
+    var weight = new int[2]; // old, new
+    var cause = new RemovalCause[1];
 
     Node<K, V> node = data.compute(keyRef, (kr, n) -> {
       if (n == null) {
@@ -2861,12 +2863,13 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
         now[0] = expirationTicker().read();
         weight[1] = weigher.weigh(key, newValue[0]);
         long varTime = expireAfterCreate(key, newValue[0], expiry, now[0]);
-        n = nodeFactory.newNode(keyRef, newValue[0], valueReferenceQueue(), weight[1], now[0]);
-        setVariableTime(n, varTime);
-        setAccessTime(n, now[0]);
-        setWriteTime(n, now[0]);
+        var created = nodeFactory.newNode(keyRef, newValue[0],
+            valueReferenceQueue(), weight[1], now[0]);
+        setVariableTime(created, varTime);
+        setAccessTime(created, now[0]);
+        setWriteTime(created, now[0]);
         discardRefresh(key);
-        return n;
+        return created;
       }
 
       synchronized (n) {
@@ -2945,7 +2948,7 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
       if (expiresAfterWrite() || (weightedDifference != 0)) {
         afterWrite(new UpdateTask(node, weightedDifference));
       } else {
-        afterRead(node, now[0], /* recordHit */ false);
+        afterRead(node, now[0], /* recordHit= */ false);
         if ((cause[0] != null) && cause[0].wasEvicted()) {
           scheduleDrainBuffers();
         }
@@ -2967,19 +2970,19 @@ public void forEach(BiConsumer<? super K, ? super V> action) {
 
   @Override
   public Set<K> keySet() {
-    final Set<K> ks = keySet;
+    Set<K> ks = keySet;
     return (ks == null) ? (keySet = new KeySetView<>(this)) : ks;
   }
 
   @Override
   public Collection<V> values() {
-    final Collection<V> vs = values;
+    Collection<V> vs = values;
     return (vs == null) ? (values = new ValuesView<>(this)) : vs;
   }
 
   @Override
   public Set<Entry<K, V>> entrySet() {
-    final Set<Entry<K, V>> es = entrySet;
+    Set<Entry<K, V>> es = entrySet;
     return (es == null) ? (entrySet = new EntrySetView<>(this)) : es;
   }
 
@@ -3039,7 +3042,7 @@ public boolean equals(Object o) {
   @Override
   @SuppressWarnings("NullAway")
   public int hashCode() {
-    int hash = 0;
+    @Var int hash = 0;
     long now = expirationTicker().read();
     for (var node : data.values()) {
       K key = node.getKey();
@@ -3125,8 +3128,10 @@ <T> T expireAfterAccessOrder(boolean oldest, Function<V, V> transformer,
     Iterable<Node<K, V>> iterable;
     if (evicts()) {
       iterable = () -> {
-        Comparator<Node<K, V>> comparator = Comparator.comparingLong(Node::getAccessTime);
-        PeekingIterator<Node<K, V>> first, second, third;
+        @Var Comparator<Node<K, V>> comparator = Comparator.comparingLong(Node::getAccessTime);
+        PeekingIterator<Node<K, V>> first;
+        PeekingIterator<Node<K, V>> second;
+        PeekingIterator<Node<K, V>> third;
         if (oldest) {
           first = accessOrderWindowDeque().iterator();
           second = accessOrderProbationDeque().iterator();
@@ -3189,7 +3194,7 @@ <T> T snapshot(Iterable<Node<K, V>> iterable, Function<V, V> transformer,
       return null;
     }
 
-    long expiresAfter = Long.MAX_VALUE;
+    @Var long expiresAfter = Long.MAX_VALUE;
     if (expiresAfterAccess()) {
       expiresAfter = Math.min(expiresAfter, now - node.getAccessTime() + expiresAfterAccessNanos());
     }
@@ -3276,7 +3281,7 @@ public boolean contains(Object o) {
     @Override
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       if ((collection instanceof Set<?>) && (collection.size() > size())) {
         for (K key : this) {
           if (collection.contains(key)) {
@@ -3299,7 +3304,7 @@ public boolean remove(Object o) {
     @Override
     public boolean removeIf(Predicate<? super K> filter) {
       requireNonNull(filter);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (K key : this) {
         if (filter.test(key) && remove(key)) {
           modified = true;
@@ -3311,7 +3316,7 @@ public boolean removeIf(Predicate<? super K> filter) {
     @Override
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (K key : this) {
         if (!collection.contains(key) && remove(key)) {
           modified = true;
@@ -3449,7 +3454,7 @@ public boolean contains(Object o) {
     @SuppressWarnings("NullAway")
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var iterator = new EntryIterator<>(cache); iterator.hasNext();) {
         if (collection.contains(iterator.value) && cache.remove(iterator.key, iterator.value)) {
           modified = true;
@@ -3478,7 +3483,7 @@ public boolean remove(Object o) {
     @SuppressWarnings("NullAway")
     public boolean removeIf(Predicate<? super V> filter) {
       requireNonNull(filter);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var iterator = new EntryIterator<>(cache); iterator.hasNext();) {
         if (filter.test(iterator.value)) {
           modified |= cache.remove(iterator.key, iterator.value);
@@ -3492,7 +3497,7 @@ public boolean removeIf(Predicate<? super V> filter) {
     @SuppressWarnings("NullAway")
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var iterator = new EntryIterator<>(cache); iterator.hasNext();) {
         if (!collection.contains(iterator.value) && cache.remove(iterator.key, iterator.value)) {
           modified = true;
@@ -3639,7 +3644,7 @@ public boolean contains(Object o) {
     @Override
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       if ((collection instanceof Set<?>) && (collection.size() > size())) {
         for (var entry : this) {
           if (collection.contains(entry)) {
@@ -3668,7 +3673,7 @@ public boolean remove(Object o) {
     @Override
     public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
       requireNonNull(filter);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (Entry<K, V> entry : this) {
         if (filter.test(entry)) {
           modified |= cache.remove(entry.getKey(), entry.getValue());
@@ -3680,7 +3685,7 @@ public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
     @Override
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var entry : this) {
         if (!collection.contains(entry) && remove(entry)) {
           modified = true;
@@ -3902,7 +3907,7 @@ public void run() {
 
   /** Creates a serialization proxy based on the common configuration shared by all cache types. */
   static <K, V> SerializationProxy<K, V> makeSerializationProxy(BoundedLocalCache<?, ?> cache) {
-    SerializationProxy<K, V> proxy = new SerializationProxy<>();
+    var proxy = new SerializationProxy<K, V>();
     proxy.weakKeys = cache.collectKeys();
     proxy.weakValues = cache.nodeFactory.weakValues();
     proxy.softValues = cache.nodeFactory.softValues();
@@ -3949,7 +3954,7 @@ static class BoundedLocalManualCache<K, V> implements LocalManualCache<K, V>, Se
     }
 
     BoundedLocalManualCache(Caffeine<K, V> builder, @Nullable CacheLoader<? super K, V> loader) {
-      cache = LocalCacheFactory.newBoundedLocalCache(builder, loader, /* async */ false);
+      cache = LocalCacheFactory.newBoundedLocalCache(builder, loader, /* isAsync= */ false);
     }
 
     @Override
@@ -4119,34 +4124,34 @@ final class BoundedEviction implements Eviction<K, V> {
       @Override public Map<K, V> coldest(int limit) {
         int expectedSize = Math.min(limit, cache.size());
         var limiter = new SizeLimiter<K, V>(expectedSize, limit);
-        return cache.evictionOrder(/* hottest */ false, transformer, limiter);
+        return cache.evictionOrder(/* hottest= */ false, transformer, limiter);
       }
       @Override public Map<K, V> coldestWeighted(long weightLimit) {
         var limiter = isWeighted()
             ? new WeightLimiter<K, V>(weightLimit)
             : new SizeLimiter<K, V>((int) Math.min(weightLimit, cache.size()), weightLimit);
-        return cache.evictionOrder(/* hottest */ false, transformer, limiter);
+        return cache.evictionOrder(/* hottest= */ false, transformer, limiter);
       }
       @Override
       public <T> T coldest(Function<Stream<CacheEntry<K, V>>, T> mappingFunction) {
         requireNonNull(mappingFunction);
-        return cache.evictionOrder(/* hottest */ false, transformer, mappingFunction);
+        return cache.evictionOrder(/* hottest= */ false, transformer, mappingFunction);
       }
       @Override public Map<K, V> hottest(int limit) {
         int expectedSize = Math.min(limit, cache.size());
         var limiter = new SizeLimiter<K, V>(expectedSize, limit);
-        return cache.evictionOrder(/* hottest */ true, transformer, limiter);
+        return cache.evictionOrder(/* hottest= */ true, transformer, limiter);
       }
       @Override public Map<K, V> hottestWeighted(long weightLimit) {
         var limiter = isWeighted()
             ? new WeightLimiter<K, V>(weightLimit)
             : new SizeLimiter<K, V>((int) Math.min(weightLimit, cache.size()), weightLimit);
-        return cache.evictionOrder(/* hottest */ true, transformer, limiter);
+        return cache.evictionOrder(/* hottest= */ true, transformer, limiter);
       }
       @Override
       public <T> T hottest(Function<Stream<CacheEntry<K, V>>, T> mappingFunction) {
         requireNonNull(mappingFunction);
-        return cache.evictionOrder(/* hottest */ true, transformer, mappingFunction);
+        return cache.evictionOrder(/* hottest= */ true, transformer, mappingFunction);
       }
     }
 
@@ -4177,13 +4182,13 @@ final class BoundedExpireAfterAccess implements FixedExpiration<K, V> {
         return oldest(new SizeLimiter<>(Math.min(limit, cache.size()), limit));
       }
       @Override public <T> T oldest(Function<Stream<CacheEntry<K, V>>, T> mappingFunction) {
-        return cache.expireAfterAccessOrder(/* oldest */ true, transformer, mappingFunction);
+        return cache.expireAfterAccessOrder(/* oldest= */ true, transformer, mappingFunction);
       }
       @Override public Map<K, V> youngest(int limit) {
         return youngest(new SizeLimiter<>(Math.min(limit, cache.size()), limit));
       }
       @Override public <T> T youngest(Function<Stream<CacheEntry<K, V>>, T> mappingFunction) {
-        return cache.expireAfterAccessOrder(/* oldest */ false, transformer, mappingFunction);
+        return cache.expireAfterAccessOrder(/* oldest= */ false, transformer, mappingFunction);
       }
     }
 
@@ -4258,7 +4263,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
             }
             node.setVariableTime(now + Math.min(durationNanos, MAXIMUM_EXPIRY));
           }
-          cache.afterRead(node, now, /* recordHit */ false);
+          cache.afterRead(node, now, /* recordHit= */ false);
         }
       }
       @Override public @Nullable V put(K key, V value, long duration, TimeUnit unit) {
@@ -4267,7 +4272,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
         requireArgument(duration >= 0);
         return cache.isAsync
             ? putAsync(key, value, duration, unit)
-            : putSync(key, value, duration, unit, /* onlyIfAbsent */ false);
+            : putSync(key, value, duration, unit, /* onlyIfAbsent= */ false);
       }
       @Override public @Nullable V putIfAbsent(K key, V value, long duration, TimeUnit unit) {
         requireNonNull(unit);
@@ -4275,7 +4280,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
         requireArgument(duration >= 0);
         return cache.isAsync
             ? putIfAbsentAsync(key, value, duration, unit)
-            : putSync(key, value, duration, unit, /* onlyIfAbsent */ true);
+            : putSync(key, value, duration, unit, /* onlyIfAbsent= */ true);
       }
       @Nullable V putSync(K key, V value, long duration, TimeUnit unit, boolean onlyIfAbsent) {
         var expiry = new FixedExpireAfterWrite<K, V>(duration, unit);
@@ -4285,10 +4290,10 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
       @Nullable V putIfAbsentAsync(K key, V value, long duration, TimeUnit unit) {
         // Keep in sync with LocalAsyncCache.AsMapView#putIfAbsent(key, value)
         var expiry = (Expiry<K, V>) new AsyncExpiry<>(new FixedExpireAfterWrite<>(duration, unit));
-        V asyncValue = (V) CompletableFuture.completedFuture(value);
+        var asyncValue = (V) CompletableFuture.completedFuture(value);
 
         for (;;) {
-          var priorFuture = (CompletableFuture<V>) cache.getIfPresent(key, /* recordStats */ false);
+          var priorFuture = (CompletableFuture<V>) cache.getIfPresent(key, /* recordStats= */ false);
           if (priorFuture != null) {
             if (!priorFuture.isDone()) {
               Async.getWhenSuccessful(priorFuture);
@@ -4307,7 +4312,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
             added[0] = (oldValueFuture == null)
                 || (oldValueFuture.isDone() && (Async.getIfReady(oldValueFuture) == null));
             return added[0] ? asyncValue : oldValue;
-          }, expiry, /* recordLoad */ false, /* recordLoadFailure */ false);
+          }, expiry, /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
           if (added[0]) {
             return null;
@@ -4322,10 +4327,10 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
       @SuppressWarnings("unchecked")
       @Nullable V putAsync(K key, V value, long duration, TimeUnit unit) {
         var expiry = (Expiry<K, V>) new AsyncExpiry<>(new FixedExpireAfterWrite<>(duration, unit));
-        V asyncValue = (V) CompletableFuture.completedFuture(value);
+        var asyncValue = (V) CompletableFuture.completedFuture(value);
 
         var oldValueFuture = (CompletableFuture<V>) cache.put(
-            key, asyncValue, expiry, /* onlyIfAbsent */ false);
+            key, asyncValue, expiry, /* onlyIfAbsent= */ false);
         return Async.getWhenSuccessful(oldValueFuture);
       }
       @SuppressWarnings("NullAway")
@@ -4342,7 +4347,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
         return cache.isAsync
             ? computeAsync(key, remappingFunction, expiry)
             : cache.compute(key, remappingFunction, expiry,
-                /* recordLoad */ true, /* recordLoadFailure */ true);
+                /* recordLoad= */ true, /* recordLoadFailure= */ true);
       }
       @Nullable V computeAsync(K key,
           BiFunction<? super K, ? super V, ? extends V> remappingFunction,
@@ -4352,7 +4357,7 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
         var delegate = (LocalCache<K, CompletableFuture<V>>) cache;
 
         @SuppressWarnings({"rawtypes", "unchecked"})
-        V[] newValue = (V[]) new Object[1];
+        var newValue = (V[]) new Object[1];
         for (;;) {
           Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));
 
@@ -4363,10 +4368,10 @@ final class BoundedVarExpiration implements VarExpiration<K, V> {
 
             V oldValue = Async.getIfReady(oldValueFuture);
             BiFunction<? super K, ? super V, ? extends V> function = delegate.statsAware(
-                remappingFunction, /* recordLoad */ true, /* recordLoadFailure */ true);
+                remappingFunction, /* recordLoad= */ true, /* recordLoadFailure= */ true);
             newValue[0] = function.apply(key, oldValue);
             return (newValue[0] == null) ? null : CompletableFuture.completedFuture(newValue[0]);
-          }, new AsyncExpiry<>(expiry), /* recordLoad */ false, /* recordLoadFailure */ false);
+          }, new AsyncExpiry<>(expiry), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
           if (newValue[0] != null) {
             return newValue[0];
@@ -4444,7 +4449,7 @@ static final class BoundedLocalLoadingCache<K, V>
     private static final long serialVersionUID = 1;
 
     final Function<K, V> mappingFunction;
-    @Nullable final Function<Set<? extends K>, Map<K, V>> bulkMappingFunction;
+    final @Nullable Function<Set<? extends K>, Map<K, V>> bulkMappingFunction;
 
     BoundedLocalLoadingCache(Caffeine<K, V> builder, CacheLoader<? super K, V> loader) {
       super(builder, loader);
@@ -4493,7 +4498,7 @@ static final class BoundedLocalAsyncCache<K, V> implements LocalAsyncCache<K, V>
     @SuppressWarnings("unchecked")
     BoundedLocalAsyncCache(Caffeine<K, V> builder) {
       cache = (BoundedLocalCache<K, CompletableFuture<V>>) LocalCacheFactory
-          .newBoundedLocalCache(builder, /* loader */ null, /* async */ true);
+          .newBoundedLocalCache(builder, /* cacheLoader= */ null, /* isAsync= */ true);
       isWeighted = builder.isWeighted();
     }
 
@@ -4516,10 +4521,10 @@ public Cache<K, V> synchronous() {
     public Policy<K, V> policy() {
       if (policy == null) {
         @SuppressWarnings("unchecked")
-        BoundedLocalCache<K, V> castCache = (BoundedLocalCache<K, V>) cache;
+        var castCache = (BoundedLocalCache<K, V>) cache;
         Function<CompletableFuture<V>, V> transformer = Async::getIfReady;
         @SuppressWarnings("unchecked")
-        Function<V, V> castTransformer = (Function<V, V>) transformer;
+        var castTransformer = (Function<V, V>) transformer;
         policy = new BoundedPolicy<>(castCache, castTransformer, isWeighted);
       }
       return policy;
@@ -4551,7 +4556,7 @@ static final class BoundedLocalAsyncLoadingCache<K, V>
       super(loader);
       isWeighted = builder.isWeighted();
       cache = (BoundedLocalCache<K, CompletableFuture<V>>) LocalCacheFactory
-          .newBoundedLocalCache(builder, loader, /* async */ true);
+          .newBoundedLocalCache(builder, loader, /* isAsync= */ true);
     }
 
     @Override
@@ -4568,10 +4573,10 @@ public ConcurrentMap<K, CompletableFuture<V>> asMap() {
     public Policy<K, V> policy() {
       if (policy == null) {
         @SuppressWarnings("unchecked")
-        BoundedLocalCache<K, V> castCache = (BoundedLocalCache<K, V>) cache;
+        var castCache = (BoundedLocalCache<K, V>) cache;
         Function<CompletableFuture<V>, V> transformer = Async::getIfReady;
         @SuppressWarnings("unchecked")
-        Function<V, V> castTransformer = (Function<V, V>) transformer;
+        var castTransformer = (Function<V, V>) transformer;
         policy = new BoundedPolicy<>(castCache, castTransformer, isWeighted);
       }
       return policy;
@@ -4588,8 +4593,11 @@ private Object writeReplace() {
 }
 
 /** The namespace for field padding through inheritance. */
+@SuppressWarnings("MultiVariableDeclaration")
 final class BLCHeader {
 
+  private BLCHeader() {}
+
   static class PadDrainStatus {
     byte p000, p001, p002, p003, p004, p005, p006, p007;
     byte p008, p009, p010, p011, p012, p013, p014, p015;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Caffeine.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Caffeine.java
index 118824d588..60c723fd75 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Caffeine.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Caffeine.java
@@ -259,7 +259,8 @@ public static Caffeine<Object, Object> newBuilder() {
   static <K> BoundedLocalCache<K, Boolean> newWeakInterner() {
     var builder = new Caffeine<K, Boolean>().executor(Runnable::run).weakKeys();
     builder.interner = true;
-    return LocalCacheFactory.newBoundedLocalCache(builder, /* loader */ null, /* async */ false);
+    return LocalCacheFactory.newBoundedLocalCache(builder,
+        /* cacheLoader= */ null, /* isAsync= */ false);
   }
 
   /**
@@ -479,7 +480,7 @@ public <K1 extends K, V1 extends V> Caffeine<K1, V1> weigher(
         "weigher can not be combined with maximum size");
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     self.weigher = weigher;
     return self;
   }
@@ -757,7 +758,7 @@ public <K1 extends K, V1 extends V> Caffeine<K1, V1> expireAfter(
         "Expiry may not be used with expiresAfterWrite");
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     self.expiry = expiry;
     return self;
   }
@@ -831,14 +832,14 @@ public Caffeine<K, V> refreshAfterWrite(@NonNegative long duration, TimeUnit uni
     return this;
   }
 
-  long getRefreshAfterWriteNanos() {
-    return refreshAfterWrite() ? refreshAfterWriteNanos : DEFAULT_REFRESH_NANOS;
-  }
-
   boolean refreshAfterWrite() {
     return refreshAfterWriteNanos != UNSET_INT;
   }
 
+  long getRefreshAfterWriteNanos() {
+    return refreshAfterWrite() ? refreshAfterWriteNanos : DEFAULT_REFRESH_NANOS;
+  }
+
   /**
    * Specifies a nanosecond-precision time source for use in determining when entries should be
    * expired or refreshed. By default, {@link System#nanoTime} is used.
@@ -908,7 +909,7 @@ public <K1 extends K, V1 extends V> Caffeine<K1, V1> evictionListener(
         "eviction listener was already set to %s", this.evictionListener);
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     self.evictionListener = requireNonNull(evictionListener);
     return self;
   }
@@ -960,14 +961,14 @@ public <K1 extends K, V1 extends V> Caffeine<K1, V1> removalListener(
         "removal listener was already set to %s", this.removalListener);
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     self.removalListener = requireNonNull(removalListener);
     return self;
   }
 
   @SuppressWarnings({"JavaAnnotator", "unchecked"})
-  @Nullable <K1 extends K, V1 extends V> RemovalListener<K1, V1> getRemovalListener(boolean async) {
-    RemovalListener<K1, V1> castedListener = (RemovalListener<K1, V1>) removalListener;
+  <K1 extends K, V1 extends V> @Nullable RemovalListener<K1, V1> getRemovalListener(boolean async) {
+    var castedListener = (RemovalListener<K1, V1>) removalListener;
     return async && (castedListener != null)
         ? (RemovalListener<K1, V1>) new AsyncRemovalListener<>(castedListener, getExecutor())
         : castedListener;
@@ -1046,7 +1047,7 @@ public <K1 extends K, V1 extends V> Cache<K1, V1> build() {
     requireNonLoadingCache();
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     return isBounded()
         ? new BoundedLocalCache.BoundedLocalManualCache<>(self)
         : new UnboundedLocalCache.UnboundedLocalManualCache<>(self);
@@ -1071,7 +1072,7 @@ public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
     requireWeightWithWeigher();
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     return isBounded() || refreshAfterWrite()
         ? new BoundedLocalCache.BoundedLocalLoadingCache<>(self, loader)
         : new UnboundedLocalCache.UnboundedLocalLoadingCache<>(self, loader);
@@ -1105,7 +1106,7 @@ public <K1 extends K, V1 extends V> AsyncCache<K1, V1> buildAsync() {
     requireNonLoadingCache();
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     return isBounded()
         ? new BoundedLocalCache.BoundedLocalAsyncCache<>(self)
         : new UnboundedLocalCache.UnboundedLocalAsyncCache<>(self);
@@ -1162,7 +1163,7 @@ public <K1 extends K, V1 extends V> AsyncLoadingCache<K1, V1> buildAsync(
     requireNonNull(loader);
 
     @SuppressWarnings("unchecked")
-    Caffeine<K1, V1> self = (Caffeine<K1, V1>) this;
+    var self = (Caffeine<K1, V1>) this;
     return isBounded() || refreshAfterWrite()
         ? new BoundedLocalCache.BoundedLocalAsyncLoadingCache<>(self, loader)
         : new UnboundedLocalCache.UnboundedLocalAsyncLoadingCache<>(self, loader);
@@ -1201,8 +1202,8 @@ static long toNanosSaturated(Duration duration) {
    */
   @Override
   public String toString() {
-    StringBuilder s = new StringBuilder(200);
-    s.append(getClass().getSimpleName()).append('{');
+    var s = new StringBuilder(200)
+        .append(getClass().getSimpleName()).append('{');
     int baseLength = s.length();
     if (initialCapacity != UNSET_INT) {
       s.append("initialCapacity=").append(initialCapacity).append(", ");
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/CaffeineSpec.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/CaffeineSpec.java
index 73ce1d61b5..a920c16953 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/CaffeineSpec.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/CaffeineSpec.java
@@ -97,7 +97,7 @@ private CaffeineSpec(String specification) {
    * @return a builder configured to the specification
    */
   Caffeine<Object, Object> toBuilder() {
-    Caffeine<Object, Object> builder = Caffeine.newBuilder();
+    var builder = Caffeine.newBuilder();
     if (initialCapacity != UNSET_INT) {
       builder.initialCapacity(initialCapacity);
     }
@@ -141,7 +141,7 @@ Caffeine<Object, Object> toBuilder() {
    */
   @SuppressWarnings("StringSplitter")
   public static CaffeineSpec parse(String specification) {
-    CaffeineSpec spec = new CaffeineSpec(specification);
+    var spec = new CaffeineSpec(specification);
     for (String option : specification.split(SPLIT_OPTIONS)) {
       spec.parseOption(option.trim());
     }
@@ -336,7 +336,7 @@ public boolean equals(@Nullable Object o) {
     } else if (!(o instanceof CaffeineSpec)) {
       return false;
     }
-    CaffeineSpec spec = (CaffeineSpec) o;
+    var spec = (CaffeineSpec) o;
     return Objects.equals(refreshAfterWrite, spec.refreshAfterWrite)
         && Objects.equals(expireAfterAccess, spec.expireAfterAccess)
         && Objects.equals(expireAfterWrite, spec.expireAfterWrite)
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/FrequencySketch.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/FrequencySketch.java
index 578a623273..39c5e05d54 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/FrequencySketch.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/FrequencySketch.java
@@ -19,6 +19,8 @@
 
 import org.checkerframework.checker.index.qual.NonNegative;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A probabilistic multiset for estimating the popularity of an element within a time window. The
  * maximum frequency of an element is limited to 15 (4-bits) and an aging process periodically
@@ -85,6 +87,7 @@ public FrequencySketch() {}
    *
    * @param maximumSize the maximum size of the cache
    */
+  @SuppressWarnings("Varifier")
   public void ensureCapacity(@NonNegative long maximumSize) {
     requireArgument(maximumSize >= 0);
     int maximum = (int) Math.min(maximumSize, Integer.MAX_VALUE >>> 1);
@@ -115,8 +118,7 @@ public boolean isNotInitialized() {
    * @param e the element to count occurrences of
    * @return the estimated number of occurrences of the element; possibly zero but never negative
    */
-  @NonNegative
-  public int frequency(E e) {
+  public @NonNegative int frequency(E e) {
     if (isNotInitialized()) {
       return 0;
     }
@@ -169,7 +171,7 @@ public void increment(E e) {
   }
 
   /** Applies a supplemental hash function to defend against a poor quality hash. */
-  static int spread(int x) {
+  static int spread(@Var int x) {
     x ^= x >>> 17;
     x *= 0xed5ad4bb;
     x ^= x >>> 11;
@@ -179,7 +181,7 @@ static int spread(int x) {
   }
 
   /** Applies another round of hashing for additional randomization. */
-  static int rehash(int x) {
+  static int rehash(@Var int x) {
     x *= 0x31848bab;
     x ^= x >>> 14;
     return x;
@@ -204,7 +206,7 @@ boolean incrementAt(int i, int j) {
 
   /** Reduces every counter by half of its original value. */
   void reset() {
-    int count = 0;
+    @Var int count = 0;
     for (int i = 0; i < table.length; i++) {
       count += Long.bitCount(table[i] & ONE_MASK);
       table[i] = (table[i] >>> 1) & RESET_MASK;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncCache.java
index ecea8b4da8..8f822dac3a 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncCache.java
@@ -49,6 +49,7 @@
 import com.github.benmanes.caffeine.cache.LocalAsyncCache.AsyncBulkCompleter.NullMapCompletionException;
 import com.github.benmanes.caffeine.cache.stats.CacheStats;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This class provides a skeletal implementation of the {@link AsyncCache} interface to minimize the
@@ -67,7 +68,7 @@ interface LocalAsyncCache<K, V> extends AsyncCache<K, V> {
 
   @Override
   default @Nullable CompletableFuture<V> getIfPresent(K key) {
-    return cache().getIfPresent(key, /* recordStats */ true);
+    return cache().getIfPresent(key, /* recordStats= */ true);
   }
 
   @Override
@@ -80,7 +81,7 @@ default CompletableFuture<V> get(K key, Function<? super K, ? extends V> mapping
   @Override
   default CompletableFuture<V> get(K key, BiFunction<? super K, ? super Executor,
       ? extends CompletableFuture<? extends V>> mappingFunction) {
-    return get(key, mappingFunction, /* recordStats */ true);
+    return get(key, mappingFunction, /* recordStats= */ true);
   }
 
   @SuppressWarnings({"FutureReturnValueIgnored", "NullAway"})
@@ -94,9 +95,9 @@ default CompletableFuture<V> get(K key, BiFunction<? super K, ? super Executor,
       var castedResult = (CompletableFuture<V>) mappingFunction.apply(key, cache().executor());
       result[0] = castedResult;
       return requireNonNull(castedResult);
-    }, recordStats, /* recordLoad */ false);
+    }, recordStats, /* recordLoad= */ false);
     if (result[0] != null) {
-      handleCompletion(key, result[0], startTime, /* recordMiss */ false);
+      handleCompletion(key, result[0], startTime, /* recordMiss= */ false);
     }
     return future;
   }
@@ -124,7 +125,7 @@ default CompletableFuture<Map<K, V>> getAll(Iterable<? extends K> keys,
       if (futures.containsKey(key)) {
         continue;
       }
-      CompletableFuture<V> future = cache().getIfPresent(key, /* recordStats */ false);
+      @Var CompletableFuture<V> future = cache().getIfPresent(key, /* recordStats= */ false);
       if (future == null) {
         var proxy = new CompletableFuture<V>();
         future = cache().putIfAbsent(key, proxy);
@@ -147,7 +148,7 @@ default CompletableFuture<Map<K, V>> getAll(Iterable<? extends K> keys,
           Collections.unmodifiableSet(proxies.keySet()), cache().executor());
       return loader.handle(completer).thenCompose(ignored -> composeResult(futures));
     } catch (Throwable t) {
-      completer.apply(/* result */ null, t);
+      completer.apply(/* result= */ null, t);
       throw t;
     }
   }
@@ -191,7 +192,7 @@ default void put(K key, CompletableFuture<? extends V> valueFuture) {
     @SuppressWarnings("unchecked")
     var castedFuture = (CompletableFuture<V>) valueFuture;
     cache().put(key, castedFuture);
-    handleCompletion(key, valueFuture, startTime, /* recordMiss */ false);
+    handleCompletion(key, valueFuture, startTime, /* recordMiss= */ false);
   }
 
   @SuppressWarnings("FutureReturnValueIgnored")
@@ -217,7 +218,7 @@ default void handleCompletion(K key, CompletableFuture<? extends V> valueFuture,
 
         try {
           // update the weight and expiration timestamps
-          cache().replace(key, castedFuture, castedFuture, /* shouldDiscardRefresh */ false);
+          cache().replace(key, castedFuture, castedFuture, /* shouldDiscardRefresh= */ false);
           cache().statsCounter().recordLoadSuccess(loadTime);
         } catch (Throwable t) {
           logger.log(Level.WARNING, "Exception thrown during asynchronous load", t);
@@ -235,6 +236,7 @@ default void handleCompletion(K key, CompletableFuture<? extends V> valueFuture,
   final class AsyncBulkCompleter<K, V>
       implements BiFunction<Map<? extends K, ? extends V>, Throwable, Map<? extends K, ? extends V>> {
     private final LocalCache<K, CompletableFuture<V>> cache;
+    @SuppressWarnings("ImmutableMemberCollection")
     private final Map<K, CompletableFuture<V>> proxies;
     private final long startTime;
 
@@ -269,17 +271,15 @@ final class AsyncBulkCompleter<K, V>
     private @Nullable Throwable handleResponse(
         @Nullable Map<? extends K, ? extends V> result, @Nullable Throwable error) {
       if (result == null) {
-        if (error == null) {
-          error = new NullMapCompletionException();
-        }
+        var failure = (error == null) ? new NullMapCompletionException() : error;
         for (var entry : proxies.entrySet()) {
           cache.remove(entry.getKey(), entry.getValue());
           entry.getValue().obtrudeException(error);
         }
-        if (!(error instanceof CancellationException) && !(error instanceof TimeoutException)) {
-          logger.log(Level.WARNING, "Exception thrown during asynchronous load", error);
+        if (!(failure instanceof CancellationException) && !(failure instanceof TimeoutException)) {
+          logger.log(Level.WARNING, "Exception thrown during asynchronous load", failure);
         }
-        return error;
+        return failure;
       } else {
         var failure = fillProxies(result);
         return addNewEntries(result, failure);
@@ -288,7 +288,7 @@ final class AsyncBulkCompleter<K, V>
 
     /** Populates the proxies with the computed result. */
     private @Nullable Throwable fillProxies(Map<? extends K, ? extends V> result) {
-      Throwable error = null;
+      @Var Throwable error = null;
       for (var entry : proxies.entrySet()) {
         var key = entry.getKey();
         var value = result.get(key);
@@ -317,7 +317,8 @@ final class AsyncBulkCompleter<K, V>
 
     /** Adds to the cache any extra entries computed that were not requested. */
     private @Nullable Throwable addNewEntries(
-        Map<? extends K, ? extends V> result, @Nullable Throwable error) {
+        Map<? extends K, ? extends V> result, @Nullable Throwable failure) {
+      @Var Throwable error = failure;
       for (var entry : result.entrySet()) {
         var key = entry.getKey();
         var value = result.get(key);
@@ -371,14 +372,14 @@ final class AsyncAsMapView<K, V> implements ConcurrentMap<K, CompletableFuture<V
       CompletableFuture<V> prior = asyncCache.cache().putIfAbsent(key, value);
       long startTime = asyncCache.cache().statsTicker().read();
       if (prior == null) {
-        asyncCache.handleCompletion(key, value, startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, value, startTime, /* recordMiss= */ false);
       }
       return prior;
     }
     @Override public CompletableFuture<V> put(K key, CompletableFuture<V> value) {
       CompletableFuture<V> prior = asyncCache.cache().put(key, value);
       long startTime = asyncCache.cache().statsTicker().read();
-      asyncCache.handleCompletion(key, value, startTime, /* recordMiss */ false);
+      asyncCache.handleCompletion(key, value, startTime, /* recordMiss= */ false);
       return prior;
     }
     @SuppressWarnings("FutureReturnValueIgnored")
@@ -389,7 +390,7 @@ final class AsyncAsMapView<K, V> implements ConcurrentMap<K, CompletableFuture<V
       CompletableFuture<V> prior = asyncCache.cache().replace(key, value);
       long startTime = asyncCache.cache().statsTicker().read();
       if (prior != null) {
-        asyncCache.handleCompletion(key, value, startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, value, startTime, /* recordMiss= */ false);
       }
       return prior;
     }
@@ -398,7 +399,7 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
       boolean replaced = asyncCache.cache().replace(key, oldValue, newValue);
       long startTime = asyncCache.cache().statsTicker().read();
       if (replaced) {
-        asyncCache.handleCompletion(key, newValue, startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, newValue, startTime, /* recordMiss= */ false);
       }
       return replaced;
     }
@@ -418,7 +419,7 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
       CompletableFuture<V> future = asyncCache.cache().computeIfAbsent(key, k -> {
         result[0] = mappingFunction.apply(k);
         return result[0];
-      }, /* recordStats */ false, /* recordLoad */ false);
+      }, /* recordStats= */ false, /* recordLoad= */ false);
 
       if (result[0] == null) {
         if ((future != null) && asyncCache.cache().isRecordingStats()) {
@@ -429,7 +430,7 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
           });
         }
       } else {
-        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss */ true);
+        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss= */ true);
       }
       return future;
     }
@@ -443,10 +444,10 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
       asyncCache.cache().compute(key, (k, oldValue) -> {
         result[0] = (oldValue == null) ? null : remappingFunction.apply(k, oldValue);
         return result[0];
-      }, asyncCache.cache().expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+      }, asyncCache.cache().expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
       if (result[0] != null) {
-        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss= */ false);
       }
       return result[0];
     }
@@ -460,10 +461,10 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
       asyncCache.cache().compute(key, (k, oldValue) -> {
         result[0] = remappingFunction.apply(k, oldValue);
         return result[0];
-      }, asyncCache.cache().expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+      }, asyncCache.cache().expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
       if (result[0] != null) {
-        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss= */ false);
       }
       return result[0];
     }
@@ -479,10 +480,10 @@ public boolean replace(K key, CompletableFuture<V> oldValue, CompletableFuture<V
       asyncCache.cache().compute(key, (k, oldValue) -> {
         result[0] = (oldValue == null) ? value : remappingFunction.apply(oldValue, value);
         return result[0];
-      }, asyncCache.cache().expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+      }, asyncCache.cache().expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
       if (result[0] != null) {
-        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss */ false);
+        asyncCache.handleCompletion(key, result[0], startTime, /* recordMiss= */ false);
       }
       return result[0];
     }
@@ -534,7 +535,7 @@ abstract class AbstractCacheView<K, V> implements Cache<K, V>, Serializable {
 
     @Override
     public @Nullable V getIfPresent(K key) {
-      CompletableFuture<V> future = asyncCache().cache().getIfPresent(key, /* recordStats */ true);
+      CompletableFuture<V> future = asyncCache().cache().getIfPresent(key, /* recordStats= */ true);
       return Async.getIfReady(future);
     }
 
@@ -574,7 +575,8 @@ public Map<K, V> getAll(Iterable<? extends K> keys,
       return resolve(asyncCache().getAll(keys, mappingFunction));
     }
 
-    @SuppressWarnings({"PMD.AvoidThrowingNullPointerException", "PMD.PreserveStackTrace"})
+    @SuppressWarnings({"PMD.AvoidThrowingNullPointerException",
+      "PMD.PreserveStackTrace", "UnusedException"})
     protected static <T> T resolve(CompletableFuture<T> future) {
       try {
         return future.join();
@@ -695,7 +697,7 @@ public boolean containsValue(Object value) {
       requireNonNull(value);
 
       // Keep in sync with BoundedVarExpiration.putIfAbsentAsync(key, value, duration, unit)
-      CompletableFuture<V> priorFuture = null;
+      @Var CompletableFuture<V> priorFuture = null;
       for (;;) {
         priorFuture = (priorFuture == null)
             ? delegate.get(key)
@@ -717,7 +719,7 @@ public boolean containsValue(Object value) {
           added[0] = (valueFuture == null)
               || (valueFuture.isDone() && (Async.getIfReady(valueFuture) == null));
           return added[0] ? CompletableFuture.completedFuture(value) : valueFuture;
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
         if (added[0]) {
           return null;
@@ -757,10 +759,10 @@ public boolean remove(Object key, Object value) {
       }
 
       @SuppressWarnings("unchecked")
-      K castedKey = (K) key;
+      var castedKey = (K) key;
       boolean[] done = { false };
       boolean[] removed = { false };
-      CompletableFuture<V> future = null;
+      @Var CompletableFuture<V> future = null;
       for (;;) {
         future = (future == null)
             ? delegate.get(castedKey)
@@ -782,7 +784,7 @@ public boolean remove(Object key, Object value) {
           V oldValue = Async.getIfReady(oldValueFuture);
           removed[0] = value.equals(oldValue);
           return (oldValue == null) || removed[0] ? null : oldValueFuture;
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ true);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ true);
 
         if (done[0]) {
           return removed[0];
@@ -795,7 +797,7 @@ public boolean remove(Object key, Object value) {
       requireNonNull(value);
 
       @SuppressWarnings({"rawtypes", "unchecked"})
-      V[] oldValue = (V[]) new Object[1];
+      var oldValue = (V[]) new Object[1];
       boolean[] done = { false };
       for (;;) {
         CompletableFuture<V> future = delegate.getIfPresentQuietly(key);
@@ -815,7 +817,7 @@ public boolean remove(Object key, Object value) {
           done[0] = true;
           oldValue[0] = Async.getIfReady(oldValueFuture);
           return (oldValue[0] == null) ? null : CompletableFuture.completedFuture(value);
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
         if (done[0]) {
           return oldValue[0];
@@ -848,7 +850,7 @@ public boolean replace(K key, V oldValue, V newValue) {
           done[0] = true;
           replaced[0] = oldValue.equals(Async.getIfReady(oldValueFuture));
           return replaced[0] ? CompletableFuture.completedFuture(newValue) : oldValueFuture;
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
         if (done[0]) {
           return replaced[0];
@@ -860,7 +862,7 @@ public boolean replace(K key, V oldValue, V newValue) {
     public @Nullable V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
       requireNonNull(mappingFunction);
 
-      CompletableFuture<V> priorFuture = null;
+      @Var CompletableFuture<V> priorFuture = null;
       for (;;) {
         priorFuture = (priorFuture == null)
             ? delegate.get(key)
@@ -886,13 +888,13 @@ public boolean replace(K key, V oldValue, V newValue) {
             return valueFuture;
           }
 
-          V newValue = delegate.statsAware(mappingFunction, /* recordLoad */ true).apply(key);
+          V newValue = delegate.statsAware(mappingFunction, /* recordLoad= */ true).apply(key);
           if (newValue == null) {
             return null;
           }
           future[0] = CompletableFuture.completedFuture(newValue);
           return future[0];
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
         V result = Async.getWhenSuccessful(computed);
         if ((computed == future[0]) || (result != null)) {
@@ -907,7 +909,7 @@ public boolean replace(K key, V oldValue, V newValue) {
       requireNonNull(remappingFunction);
 
       @SuppressWarnings({"rawtypes", "unchecked"})
-      V[] newValue = (V[]) new Object[1];
+      var newValue = (V[]) new Object[1];
       for (;;) {
         Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));
 
@@ -940,7 +942,7 @@ public boolean replace(K key, V oldValue, V newValue) {
       requireNonNull(remappingFunction);
 
       @SuppressWarnings({"rawtypes", "unchecked"})
-      V[] newValue = (V[]) new Object[1];
+      var newValue = (V[]) new Object[1];
       for (;;) {
         Async.getWhenSuccessful(delegate.getIfPresentQuietly(key));
 
@@ -951,10 +953,10 @@ public boolean replace(K key, V oldValue, V newValue) {
 
           V oldValue = Async.getIfReady(oldValueFuture);
           BiFunction<? super K, ? super V, ? extends V> function = delegate.statsAware(
-              remappingFunction, /* recordLoad */ true, /* recordLoadFailure */ true);
+              remappingFunction, /* recordLoad= */ true, /* recordLoadFailure= */ true);
           newValue[0] = function.apply(key, oldValue);
           return (newValue[0] == null) ? null : CompletableFuture.completedFuture(newValue[0]);
-        }, delegate.expiry(), /* recordLoad */ false, /* recordLoadFailure */ false);
+        }, delegate.expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ false);
 
         if (newValue[0] != null) {
           return newValue[0];
@@ -1033,7 +1035,7 @@ public boolean equals(Object o) {
         return false;
       }
 
-      int count = 0;
+      @Var int count = 0;
       for (var iterator = new EntryIterator(); iterator.hasNext();) {
         var entry = iterator.next();
         var value = map.get(entry.getKey());
@@ -1047,7 +1049,7 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-      int hash = 0;
+      @Var int hash = 0;
       for (var iterator = new EntryIterator(); iterator.hasNext();) {
         var entry = iterator.next();
         hash += entry.hashCode();
@@ -1161,7 +1163,7 @@ public boolean contains(Object o) {
       @Override
       public boolean removeAll(Collection<?> collection) {
         requireNonNull(collection);
-        boolean modified = false;
+        @Var boolean modified = false;
         for (var entry : delegate.entrySet()) {
           V value = Async.getIfReady(entry.getValue());
           if ((value != null) && collection.contains(value)
@@ -1198,7 +1200,7 @@ public boolean removeIf(Predicate<? super V> filter) {
       @Override
       public boolean retainAll(Collection<?> collection) {
         requireNonNull(collection);
-        boolean modified = false;
+        @Var boolean modified = false;
         for (var entry : delegate.entrySet()) {
           V value = Async.getIfReady(entry.getValue());
           if ((value != null) && !collection.contains(value)
@@ -1265,7 +1267,7 @@ public boolean contains(Object o) {
         if (!(o instanceof Entry<?, ?>)) {
           return false;
         }
-        Entry<?, ?> entry = (Entry<?, ?>) o;
+        var entry = (Entry<?, ?>) o;
         var key = entry.getKey();
         var value = entry.getValue();
         if ((key == null) || (value == null)) {
@@ -1278,7 +1280,7 @@ public boolean contains(Object o) {
       @Override
       public boolean removeAll(Collection<?> collection) {
         requireNonNull(collection);
-        boolean modified = false;
+        @Var boolean modified = false;
         if ((collection instanceof Set<?>) && (collection.size() > size())) {
           for (var entry : this) {
             if (collection.contains(entry)) {
@@ -1298,7 +1300,7 @@ public boolean remove(Object obj) {
         if (!(obj instanceof Entry<?, ?>)) {
           return false;
         }
-        Entry<?, ?> entry = (Entry<?, ?>) obj;
+        var entry = (Entry<?, ?>) obj;
         var key = entry.getKey();
         return (key != null) && AsMapView.this.remove(key, entry.getValue());
       }
@@ -1306,7 +1308,7 @@ public boolean remove(Object obj) {
       @Override
       public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
         requireNonNull(filter);
-        boolean modified = false;
+        @Var boolean modified = false;
         for (Entry<K, V> entry : this) {
           if (filter.test(entry)) {
             modified |= AsMapView.this.remove(entry.getKey(), entry.getValue());
@@ -1318,7 +1320,7 @@ public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
       @Override
       public boolean retainAll(Collection<?> collection) {
         requireNonNull(collection);
-        boolean modified = false;
+        @Var boolean modified = false;
         for (var entry : this) {
           if (!collection.contains(entry) && remove(entry)) {
             modified = true;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncLoadingCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncLoadingCache.java
index 838b198070..24d8077f0e 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncLoadingCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncLoadingCache.java
@@ -35,6 +35,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * This class provides a skeletal implementation of the {@link AsyncLoadingCache} interface to
  * minimize the effort required to implement a {@link LocalCache}.
@@ -106,7 +108,7 @@ BiFunction<Set<? extends K>, Executor, CompletableFuture<Map<K, V>>> newBulkMapp
   /** Returns whether the supplied cache loader has bulk load functionality. */
   boolean canBulkLoad(AsyncCacheLoader<?, ?> loader) {
     try {
-      Class<?> defaultLoaderClass = AsyncCacheLoader.class;
+      @Var Class<?> defaultLoaderClass = AsyncCacheLoader.class;
       if (loader instanceof CacheLoader<?, ?>) {
         defaultLoaderClass = CacheLoader.class;
 
@@ -189,7 +191,7 @@ public CompletableFuture<V> refresh(K key) {
 
       Object keyReference = asyncCache.cache().referenceKey(key);
       for (;;) {
-        var future = tryOptimisticRefresh(key, keyReference);
+        @Var var future = tryOptimisticRefresh(key, keyReference);
         if (future == null) {
           future = tryComputeRefresh(key, keyReference);
         }
@@ -230,7 +232,7 @@ public CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys) {
         if (oldValueFuture != null) {
           asyncCache.cache().remove(key, oldValueFuture);
         }
-        var future = asyncCache.get(key, asyncCache.mappingFunction, /* recordStats */ false);
+        var future = asyncCache.get(key, asyncCache.mappingFunction, /* recordStats= */ false);
         @SuppressWarnings("unchecked")
         var prior = (CompletableFuture<V>) asyncCache.cache()
             .refreshes().putIfAbsent(keyReference, future);
@@ -301,7 +303,7 @@ public CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys) {
               var successful = asyncCache.cache().refreshes().remove(keyReference, castedFuture);
               if (successful && (currentValue == oldValueFuture[0])) {
                 if (currentValue == null) {
-                  // If the entry is absent then discard the refresh and maybe notifying the listener
+                  // If absent then discard the refresh and maybe notifying the listener
                   discard[0] = (newValue != null);
                   return null;
                 } else if ((currentValue == newValue) || (currentValue == castedFuture)) {
@@ -316,7 +318,7 @@ public CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys) {
               // Otherwise, a write invalidated the refresh so discard it and notify the listener
               discard[0] = true;
               return currentValue;
-            }, asyncCache.cache().expiry(), /* recordLoad */ false, /* recordLoadFailure */ true);
+            }, asyncCache.cache().expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ true);
 
             if (discard[0] && (newValue != null)) {
               var cause = (value == null) ? RemovalCause.EXPLICIT : RemovalCause.REPLACED;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCache.java
index 0c63293071..e9e62661e4 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCache.java
@@ -97,7 +97,7 @@ interface LocalCache<K, V> extends ConcurrentMap<K, V> {
   default @Nullable V compute(K key,
       BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
     return compute(key, remappingFunction, expiry(),
-        /* recordLoad */ true, /* recordLoadFailure */ true);
+        /* recordLoad= */ true, /* recordLoadFailure= */ true);
   }
 
   /**
@@ -109,7 +109,7 @@ interface LocalCache<K, V> extends ConcurrentMap<K, V> {
 
   @Override
   default @Nullable V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
-    return computeIfAbsent(key, mappingFunction, /* recordStats */ true, /* recordLoad */ true);
+    return computeIfAbsent(key, mappingFunction, /* recordStats= */ true, /* recordLoad= */ true);
   }
 
   /**
@@ -184,7 +184,7 @@ default void notifyOnReplace(K key, V oldValue, V newValue) {
   /** Decorates the remapping function to record statistics if enabled. */
   default <T, U, R> BiFunction<? super T, ? super U, ? extends R> statsAware(
       BiFunction<? super T, ? super U, ? extends R> remappingFunction) {
-    return statsAware(remappingFunction, /* recordLoad */ true, /* recordLoadFailure */ true);
+    return statsAware(remappingFunction, /* recordLoad= */ true, /* recordLoadFailure= */ true);
   }
 
   /** Decorates the remapping function to record statistics if enabled. */
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCacheFactory.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCacheFactory.java
index d5b13a4ce7..b1295ccc52 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCacheFactory.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalCacheFactory.java
@@ -23,6 +23,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A factory for caches optimized for a particular configuration.
  *
@@ -37,15 +39,15 @@ interface LocalCacheFactory {
 
   /** Returns a cache optimized for this configuration. */
   <K, V> BoundedLocalCache<K, V> newInstance(Caffeine<K, V> builder,
-      @Nullable AsyncCacheLoader<? super K, V> cacheLoader, boolean async) throws Throwable;
+      @Nullable AsyncCacheLoader<? super K, V> cacheLoader, boolean isAsync) throws Throwable;
 
   /** Returns a cache optimized for this configuration. */
   static <K, V> BoundedLocalCache<K, V> newBoundedLocalCache(Caffeine<K, V> builder,
-      @Nullable AsyncCacheLoader<? super K, V> cacheLoader, boolean async) {
+      @Nullable AsyncCacheLoader<? super K, V> cacheLoader, boolean isAsync) {
     var className = getClassName(builder);
     var factory = loadFactory(className);
     try {
-      return factory.newInstance(builder, cacheLoader, async);
+      return factory.newInstance(builder, cacheLoader, isAsync);
     } catch (RuntimeException | Error e) {
       throw e;
     } catch (Throwable t) {
@@ -92,7 +94,7 @@ static String getClassName(Caffeine<?, ?> builder) {
   }
 
   static LocalCacheFactory loadFactory(String className) {
-    var factory = FACTORIES.get(className);
+    @Var var factory = FACTORIES.get(className);
     if (factory == null) {
       factory = FACTORIES.computeIfAbsent(className, LocalCacheFactory::newFactory);
     }
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalLoadingCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalLoadingCache.java
index 376fd810b8..0f62d1aefe 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalLoadingCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalLoadingCache.java
@@ -34,6 +34,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * This class provides a skeletal implementation of the {@link LoadingCache} interface to minimize
  * the effort required to implement a {@link LocalCache}.
@@ -73,7 +75,7 @@ default Map<K, V> loadSequentially(Iterable<? extends K> keys) {
       result.put(key, null);
     }
 
-    int count = 0;
+    @Var int count = 0;
     try {
       for (var iter = result.entrySet().iterator(); iter.hasNext();) {
         Map.Entry<K, V> entry = iter.next();
@@ -100,7 +102,7 @@ default CompletableFuture<V> refresh(K key) {
 
     long[] startTime = new long[1];
     @SuppressWarnings("unchecked")
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     @SuppressWarnings({"rawtypes", "unchecked"})
     CompletableFuture<? extends V>[] reloading = new CompletableFuture[1];
     Object keyReference = cache().referenceKey(key);
@@ -148,7 +150,7 @@ default CompletableFuture<V> refresh(K key) {
           }
           discard[0] = (currentValue != newValue);
           return currentValue;
-        }, cache().expiry(), /* recordLoad */ false, /* recordLoadFailure */ true);
+        }, cache().expiry(), /* recordLoad= */ false, /* recordLoadFailure= */ true);
 
         if (discard[0] && (newValue != null)) {
           var cause = (value == null) ? RemovalCause.EXPLICIT : RemovalCause.REPLACED;
@@ -163,7 +165,7 @@ default CompletableFuture<V> refresh(K key) {
     }
 
     @SuppressWarnings("unchecked")
-    CompletableFuture<V> castedFuture = (CompletableFuture<V>) future;
+    var castedFuture = (CompletableFuture<V>) future;
     return castedFuture;
   }
 
@@ -201,7 +203,7 @@ static <K, V> Function<K, V> newMappingFunction(CacheLoader<? super K, V> cacheL
     return keysToLoad -> {
       try {
         @SuppressWarnings("unchecked")
-        Map<K, V> loaded = (Map<K, V>) cacheLoader.loadAll(keysToLoad);
+        var loaded = (Map<K, V>) cacheLoader.loadAll(keysToLoad);
         return loaded;
       } catch (RuntimeException e) {
         throw e;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalManualCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalManualCache.java
index b3f6251bd0..f57a35d238 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalManualCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalManualCache.java
@@ -29,6 +29,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import com.github.benmanes.caffeine.cache.stats.CacheStats;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This class provides a skeletal implementation of the {@link Cache} interface to minimize the
@@ -53,7 +54,7 @@ default void cleanUp() {
 
   @Override
   default @Nullable V getIfPresent(K key) {
-    return cache().getIfPresent(key, /* recordStats */ true);
+    return cache().getIfPresent(key, /* recordStats= */ true);
   }
 
   @Override
@@ -97,8 +98,8 @@ default Map<K, V> getAll(Iterable<? extends K> keys,
    */
   default void bulkLoad(Set<K> keysToLoad, Map<K, V> result,
       Function<? super Set<? extends K>, ? extends Map<? extends K, ? extends V>> mappingFunction) {
-    boolean success = false;
     long startTime = cache().statsTicker().read();
+    @Var boolean success = false;
     try {
       var loaded = mappingFunction.apply(Collections.unmodifiableSet(keysToLoad));
       loaded.forEach(cache()::put);
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueue.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueue.java
index b89c4de4b2..2ed0011b45 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueue.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueue.java
@@ -21,6 +21,8 @@
 import java.util.AbstractQueue;
 import java.util.Iterator;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * An MPSC array queue which starts at <i>initialCapacity</i> and grows to <i>maxCapacity</i> in
  * linked chunks of the initial size. The queue grows only when the current buffer is full and
@@ -51,7 +53,7 @@ protected int getNextBufferSize(E[] buffer) {
     if (buffer.length > maxSize) {
       throw new IllegalStateException();
     }
-    final int newSize = 2 * (buffer.length - 1);
+    int newSize = 2 * (buffer.length - 1);
     return newSize + 1;
   }
 
@@ -61,7 +63,7 @@ protected long getCurrentBufferCapacity(long mask) {
   }
 }
 
-@SuppressWarnings("OvershadowingSubclassFields")
+@SuppressWarnings({"MultiVariableDeclaration", "OvershadowingSubclassFields"})
 abstract class MpscChunkedArrayQueue<E> extends MpscChunkedArrayQueueColdProducerFields<E> {
   byte p000, p001, p002, p003, p004, p005, p006, p007;
   byte p008, p009, p010, p011, p012, p013, p014, p015;
@@ -110,6 +112,7 @@ abstract class MpscChunkedArrayQueueColdProducerFields<E> extends BaseMpscLinked
   }
 }
 
+@SuppressWarnings("MultiVariableDeclaration")
 abstract class BaseMpscLinkedArrayQueuePad1<E> extends AbstractQueue<E> {
   byte p000, p001, p002, p003, p004, p005, p006, p007;
   byte p008, p009, p010, p011, p012, p013, p014, p015;
@@ -132,7 +135,7 @@ abstract class BaseMpscLinkedArrayQueueProducerFields<E> extends BaseMpscLinkedA
   protected long producerIndex;
 }
 
-@SuppressWarnings("OvershadowingSubclassFields")
+@SuppressWarnings({"MultiVariableDeclaration", "OvershadowingSubclassFields"})
 abstract class BaseMpscLinkedArrayQueuePad2<E> extends BaseMpscLinkedArrayQueueProducerFields<E> {
   byte p000, p001, p002, p003, p004, p005, p006, p007;
   byte p008, p009, p010, p011, p012, p013, p014, p015;
@@ -158,7 +161,7 @@ abstract class BaseMpscLinkedArrayQueueConsumerFields<E> extends BaseMpscLinkedA
   protected long consumerIndex;
 }
 
-@SuppressWarnings("OvershadowingSubclassFields")
+@SuppressWarnings({"MultiVariableDeclaration", "OvershadowingSubclassFields"})
 abstract class BaseMpscLinkedArrayQueuePad3<E> extends BaseMpscLinkedArrayQueueConsumerFields<E> {
   byte p000, p001, p002, p003, p004, p005, p006, p007;
   byte p008, p009, p010, p011, p012, p013, p014, p015;
@@ -200,7 +203,7 @@ abstract class BaseMpscLinkedArrayQueue<E> extends BaseMpscLinkedArrayQueueColdP
    * @param initialCapacity the queue initial capacity. If chunk size is fixed this will be the
    *        chunk size. Must be 2 or more.
    */
-  BaseMpscLinkedArrayQueue(final int initialCapacity) {
+  BaseMpscLinkedArrayQueue(int initialCapacity) {
     if (initialCapacity < 2) {
       throw new IllegalArgumentException("Initial capacity must be 2 or more");
     }
@@ -229,14 +232,14 @@ public String toString() {
 
   @Override
   @SuppressWarnings("MissingDefault")
-  public boolean offer(final E e) {
+  public boolean offer(E e) {
     if (e == null) {
       throw new NullPointerException();
     }
 
-    long mask;
-    E[] buffer;
-    long pIndex;
+    @Var long mask;
+    @Var E[] buffer;
+    @Var long pIndex;
 
     while (true) {
       long producerLimit = lvProducerLimit();
@@ -273,7 +276,7 @@ public boolean offer(final E e) {
       }
     }
     // INDEX visible before ELEMENT, consistent with consumer expectation
-    final long offset = modifiedCalcElementOffset(pIndex, mask);
+    long offset = modifiedCalcElementOffset(pIndex, mask);
     soElement(buffer, offset, e);
     return true;
   }
@@ -282,8 +285,8 @@ public boolean offer(final E e) {
    * We do not inline resize into this method because we do not resize on fill.
    */
   private int offerSlowPath(long mask, long pIndex, long producerLimit) {
-    int result;
-    final long cIndex = lvConsumerIndex(this);
+    @Var int result;
+    long cIndex = lvConsumerIndex(this);
     long bufferCapacity = getCurrentBufferCapacity(mask);
     result = 0;// 0 - goto pIndex CAS
     if (cIndex + bufferCapacity > pIndex) {
@@ -307,7 +310,7 @@ else if (casProducerIndex(this, pIndex, pIndex + 1)) {
   /**
    * @return available elements in queue * 2
    */
-  protected abstract long availableInQueue(long pIndex, final long cIndex);
+  protected abstract long availableInQueue(long pIndex, long cIndex);
 
   /**
    * {@inheritDoc}
@@ -317,12 +320,12 @@ else if (casProducerIndex(this, pIndex, pIndex + 1)) {
   @Override
   @SuppressWarnings({"CastCanBeRemovedNarrowingVariableType", "unchecked"})
   public E poll() {
-    final E[] buffer = consumerBuffer;
-    final long index = consumerIndex;
-    final long mask = consumerMask;
+    E[] buffer = consumerBuffer;
+    long index = consumerIndex;
+    long mask = consumerMask;
 
-    final long offset = modifiedCalcElementOffset(index, mask);
-    Object e = lvElement(buffer, offset);// LoadLoad
+    long offset = modifiedCalcElementOffset(index, mask);
+    @Var Object e = lvElement(buffer, offset);// LoadLoad
     if (e == null) {
       if (index != lvProducerIndex(this)) {
         // poll() == null iff queue is empty, null element is not strong enough indicator, so we
@@ -336,7 +339,7 @@ public E poll() {
       }
     }
     if (e == JUMP) {
-      final E[] nextBuffer = getNextBuffer(buffer, mask);
+      E[] nextBuffer = getNextBuffer(buffer, mask);
       return newBufferPoll(nextBuffer, index);
     }
     soElement(buffer, offset, null);
@@ -352,12 +355,12 @@ public E poll() {
   @Override
   @SuppressWarnings({"CastCanBeRemovedNarrowingVariableType", "unchecked"})
   public E peek() {
-    final E[] buffer = consumerBuffer;
-    final long index = consumerIndex;
-    final long mask = consumerMask;
+    E[] buffer = consumerBuffer;
+    long index = consumerIndex;
+    long mask = consumerMask;
 
-    final long offset = modifiedCalcElementOffset(index, mask);
-    Object e = lvElement(buffer, offset);// LoadLoad
+    long offset = modifiedCalcElementOffset(index, mask);
+    @Var Object e = lvElement(buffer, offset);// LoadLoad
     if (e == null && index != lvProducerIndex(this)) {
       // peek() == null iff queue is empty, null element is not strong enough indicator, so we must
       // check the producer index. If the queue is indeed not empty we spin until element is
@@ -373,20 +376,20 @@ public E peek() {
   }
 
   @SuppressWarnings("unchecked")
-  private E[] getNextBuffer(final E[] buffer, final long mask) {
-    final long nextArrayOffset = nextArrayOffset(mask);
-    final E[] nextBuffer = (E[]) lvElement(buffer, nextArrayOffset);
+  private E[] getNextBuffer(E[] buffer, long mask) {
+    long nextArrayOffset = nextArrayOffset(mask);
+    var nextBuffer = (E[]) lvElement(buffer, nextArrayOffset);
     soElement(buffer, nextArrayOffset, null);
     return nextBuffer;
   }
 
-  private long nextArrayOffset(final long mask) {
+  private static long nextArrayOffset(long mask) {
     return modifiedCalcElementOffset(mask + 2, Long.MAX_VALUE);
   }
 
-  private E newBufferPoll(E[] nextBuffer, final long index) {
-    final long offsetInNew = newBufferAndOffset(nextBuffer, index);
-    final E n = lvElement(nextBuffer, offsetInNew);// LoadLoad
+  private E newBufferPoll(E[] nextBuffer, long index) {
+    long offsetInNew = newBufferAndOffset(nextBuffer, index);
+    E n = lvElement(nextBuffer, offsetInNew);// LoadLoad
     if (n == null) {
       throw new IllegalStateException("new buffer must have at least one element");
     }
@@ -395,16 +398,16 @@ private E newBufferPoll(E[] nextBuffer, final long index) {
     return n;
   }
 
-  private E newBufferPeek(E[] nextBuffer, final long index) {
-    final long offsetInNew = newBufferAndOffset(nextBuffer, index);
-    final E n = lvElement(nextBuffer, offsetInNew);// LoadLoad
+  private E newBufferPeek(E[] nextBuffer, long index) {
+    long offsetInNew = newBufferAndOffset(nextBuffer, index);
+    E n = lvElement(nextBuffer, offsetInNew);// LoadLoad
     if (n == null) {
       throw new IllegalStateException("new buffer must have at least one element");
     }
     return n;
   }
 
-  private long newBufferAndOffset(E[] nextBuffer, final long index) {
+  private long newBufferAndOffset(E[] nextBuffer, long index) {
     consumerBuffer = nextBuffer;
     consumerMask = (nextBuffer.length - 2L) << 1;
     return modifiedCalcElementOffset(index, consumerMask);
@@ -420,11 +423,11 @@ public final int size() {
      * In the event of concurrent polls/offers to this method the size is OVER estimated as we read
      * consumer index BEFORE the producer index.
      */
-    long after = lvConsumerIndex(this);
+    @Var long after = lvConsumerIndex(this);
     long size;
     while (true) {
-      final long before = after;
-      final long currentProducerIndex = lvProducerIndex(this);
+      long before = after;
+      long currentProducerIndex = lvProducerIndex(this);
       after = lvConsumerIndex(this);
       if (before == after) {
         size = ((currentProducerIndex - after) >> 1);
@@ -469,17 +472,17 @@ public boolean relaxedOffer(E e) {
 
   @SuppressWarnings({"CastCanBeRemovedNarrowingVariableType", "unchecked"})
   public E relaxedPoll() {
-    final E[] buffer = consumerBuffer;
-    final long index = consumerIndex;
-    final long mask = consumerMask;
+    E[] buffer = consumerBuffer;
+    long index = consumerIndex;
+    long mask = consumerMask;
 
-    final long offset = modifiedCalcElementOffset(index, mask);
+    long offset = modifiedCalcElementOffset(index, mask);
     Object e = lvElement(buffer, offset);// LoadLoad
     if (e == null) {
       return null;
     }
     if (e == JUMP) {
-      final E[] nextBuffer = getNextBuffer(buffer, mask);
+      E[] nextBuffer = getNextBuffer(buffer, mask);
       return newBufferPoll(nextBuffer, index);
     }
     soElement(buffer, offset, null);
@@ -489,11 +492,11 @@ public E relaxedPoll() {
 
   @SuppressWarnings({"CastCanBeRemovedNarrowingVariableType", "unchecked"})
   public E relaxedPeek() {
-    final E[] buffer = consumerBuffer;
-    final long index = consumerIndex;
-    final long mask = consumerMask;
+    E[] buffer = consumerBuffer;
+    long index = consumerIndex;
+    long mask = consumerMask;
 
-    final long offset = modifiedCalcElementOffset(index, mask);
+    long offset = modifiedCalcElementOffset(index, mask);
     Object e = lvElement(buffer, offset);// LoadLoad
     if (e == JUMP) {
       return newBufferPeek(getNextBuffer(buffer, mask), index);
@@ -501,23 +504,23 @@ public E relaxedPeek() {
     return (E) e;
   }
 
-  private void resize(long oldMask, E[] oldBuffer, long pIndex, final E e) {
+  private void resize(long oldMask, E[] oldBuffer, long pIndex, E e) {
     int newBufferLength = getNextBufferSize(oldBuffer);
-    final E[] newBuffer = allocate(newBufferLength);
+    E[] newBuffer = allocate(newBufferLength);
 
     producerBuffer = newBuffer;
-    final int newMask = (newBufferLength - 2) << 1;
+    int newMask = (newBufferLength - 2) << 1;
     producerMask = newMask;
 
-    final long offsetInOld = modifiedCalcElementOffset(pIndex, oldMask);
-    final long offsetInNew = modifiedCalcElementOffset(pIndex, newMask);
+    long offsetInOld = modifiedCalcElementOffset(pIndex, oldMask);
+    long offsetInNew = modifiedCalcElementOffset(pIndex, newMask);
 
     soElement(newBuffer, offsetInNew, e);// element in new array
     soElement(oldBuffer, nextArrayOffset(oldMask), newBuffer);// buffer linked
 
     // ASSERT code
-    final long cIndex = lvConsumerIndex(this);
-    final long availableInQueue = availableInQueue(pIndex, cIndex);
+    long cIndex = lvConsumerIndex(this);
+    long availableInQueue = availableInQueue(pIndex, cIndex);
     if (availableInQueue <= 0) {
       throw new IllegalStateException();
     }
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Node.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Node.java
index ae926493f4..3304ce4b44 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Node.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Node.java
@@ -35,8 +35,7 @@
 abstract class Node<K, V> implements AccessOrder<Node<K, V>>, WriteOrder<Node<K, V>> {
 
   /** Return the key or {@code null} if it has been reclaimed by the garbage collector. */
-  @Nullable
-  public abstract K getKey();
+  public abstract @Nullable K getKey();
 
   /**
    * Returns the reference that the cache is holding the entry by. This is either the key if
@@ -45,8 +44,7 @@ abstract class Node<K, V> implements AccessOrder<Node<K, V>>, WriteOrder<Node<K,
   public abstract Object getKeyReference();
 
   /** Return the value or {@code null} if it has been reclaimed by the garbage collector. */
-  @Nullable
-  public abstract V getValue();
+  public abstract @Nullable V getValue();
 
   /**
    * Returns the reference to the value. This is either the value if strongly held or a
@@ -65,9 +63,8 @@ abstract class Node<K, V> implements AccessOrder<Node<K, V>>, WriteOrder<Node<K,
   public abstract boolean containsValue(Object value);
 
   /** Returns the weight of this entry from the entry's perspective. */
-  @NonNegative
   @GuardedBy("this")
-  public int getWeight() {
+  public @NonNegative int getWeight() {
     return 1;
   }
 
@@ -76,9 +73,8 @@ public int getWeight() {
   public void setWeight(@NonNegative int weight) {}
 
   /** Returns the weight of this entry from the policy's perspective. */
-  @NonNegative
   // @GuardedBy("evictionLock")
-  public int getPolicyWeight() {
+  public @NonNegative int getPolicyWeight() {
     return 1;
   }
 
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/NodeFactory.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/NodeFactory.java
index c7369ae546..a459f663ac 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/NodeFactory.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/NodeFactory.java
@@ -23,6 +23,7 @@
 
 import com.github.benmanes.caffeine.cache.References.LookupKeyReference;
 import com.github.benmanes.caffeine.cache.References.WeakKeyReference;
+import com.google.errorprone.annotations.Var;
 
 /**
  * A factory for cache nodes optimized for a particular configuration.
@@ -136,7 +137,7 @@ static String getClassName(Caffeine<?, ?> builder, boolean isAsync) {
 
   @SuppressWarnings("unchecked")
   static <K, V> NodeFactory<K, V> loadFactory(String className) {
-    var factory = FACTORIES.get(className);
+    @Var var factory = FACTORIES.get(className);
     if (factory == null) {
       factory = FACTORIES.computeIfAbsent(className, NodeFactory::newFactory);
     }
@@ -157,10 +158,10 @@ static NodeFactory<Object, Object> newFactory(String className) {
   }
 
   final class RetiredWeakKey extends WeakKeyReference<Object> {
-    RetiredWeakKey() { super(/* key */ null, /* referenceQueue */ null); }
+    RetiredWeakKey() { super(/* key= */ null, /* queue= */ null); }
   }
   final class DeadWeakKey extends WeakKeyReference<Object> {
-    DeadWeakKey() { super(/* key */ null, /* referenceQueue */ null); }
+    DeadWeakKey() { super(/* key= */ null, /* queue= */ null); }
   }
   final class RetiredStrongKey {}
   final class DeadStrongKey {}
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Policy.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Policy.java
index eff0a3329c..7cc115da99 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Policy.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Policy.java
@@ -76,8 +76,7 @@ public interface Policy<K, V> {
    *         mapping for the key
    * @throws NullPointerException if the specified key is null
    */
-  @Nullable
-  default CacheEntry<K, V> getEntryIfPresentQuietly(K key) {
+  default @Nullable CacheEntry<K, V> getEntryIfPresentQuietly(K key) {
     // This method was added & implemented in version 3.0.6
     throw new UnsupportedOperationException();
   }
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/References.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/References.java
index 54b261a3db..02cb98f3b3 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/References.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/References.java
@@ -69,7 +69,7 @@ default boolean referenceEquals(@Nullable Object object) {
       if (object == this) {
         return true;
       } else if (object instanceof InternalReference<?>) {
-        InternalReference<?> referent = (InternalReference<?>) object;
+        var referent = (InternalReference<?>) object;
         return (get() == referent.get());
       }
       return false;
@@ -87,7 +87,7 @@ default boolean objectEquals(Object object) {
       if (object == this) {
         return true;
       } else if (object instanceof InternalReference<?>) {
-        InternalReference<?> referent = (InternalReference<?>) object;
+        var referent = (InternalReference<?>) object;
         return Objects.equals(get(), referent.get());
       }
       return false;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SerializationProxy.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SerializationProxy.java
index 206d11ba57..2b513a2b54 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SerializationProxy.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SerializationProxy.java
@@ -52,7 +52,7 @@ final class SerializationProxy<K, V> implements Serializable {
   @Nullable RemovalListener<?, ?> evictionListener;
 
   Caffeine<Object, Object> recreateCaffeine() {
-    Caffeine<Object, Object> builder = Caffeine.newBuilder();
+    var builder = Caffeine.newBuilder();
     if (ticker != null) {
       builder.ticker(ticker);
     }
@@ -99,13 +99,13 @@ Caffeine<Object, Object> recreateCaffeine() {
   }
 
   Object readResolve() {
-    Caffeine<Object, Object> builder = recreateCaffeine();
+    var builder = recreateCaffeine();
     if (async) {
       if (cacheLoader == null) {
         return builder.buildAsync();
       }
       @SuppressWarnings("unchecked")
-      AsyncCacheLoader<K, V> loader = (AsyncCacheLoader<K, V>) cacheLoader;
+      var loader = (AsyncCacheLoader<K, V>) cacheLoader;
       return builder.buildAsync(loader);
     }
 
@@ -113,7 +113,7 @@ Object readResolve() {
       return builder.build();
     }
     @SuppressWarnings("unchecked")
-    CacheLoader<K, V> loader = (CacheLoader<K, V>) cacheLoader;
+    var loader = (CacheLoader<K, V>) cacheLoader;
     return builder.build(loader);
   }
 }
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SnapshotEntry.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SnapshotEntry.java
index edc15285fd..4f4e7db6ba 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SnapshotEntry.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/SnapshotEntry.java
@@ -77,7 +77,7 @@ class SnapshotEntry<K, V> implements CacheEntry<K, V> {
 
   /** Returns a cache entry containing the given key, value, and snapshot. */
   public static <K, V> SnapshotEntry<K, V> forEntry(K key, V value) {
-    return new SnapshotEntry<>(key, value, /* snapshot */ 0);
+    return new SnapshotEntry<>(key, value, /* snapshot= */ 0);
   }
 
   /** Returns a cache entry with the specified metadata. */
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/StripedBuffer.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/StripedBuffer.java
index 2d06d1f8c9..c95ede8d87 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/StripedBuffer.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/StripedBuffer.java
@@ -29,6 +29,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A base class providing the mechanics for supporting dynamic striping of bounded buffers. This
  * implementation is an adaption of the numeric 64-bit <i>java.util.concurrent.atomic.Striped64</i>
@@ -115,6 +117,7 @@ final boolean casTableBusy() {
   protected abstract Buffer<E> create(E e);
 
   @Override
+  @SuppressWarnings("Varifier")
   public int offer(E e) {
     @SuppressWarnings("deprecation")
     long z = mix64(Thread.currentThread().getId());
@@ -124,7 +127,7 @@ public int offer(E e) {
     int mask;
     int result;
     Buffer<E> buffer;
-    boolean uncontended = true;
+    @Var boolean uncontended = true;
     Buffer<E>[] buffers = table;
     if ((buffers == null)
         || ((mask = buffers.length - 1) < 0)
@@ -146,9 +149,9 @@ public int offer(E e) {
    * @param wasUncontended false if CAS failed before this call
    * @return {@code Buffer.SUCCESS}, {@code Buffer.FAILED}, or {@code Buffer.FULL}
    */
-  final int expandOrRetry(E e, int h, int increment, boolean wasUncontended) {
-    int result = Buffer.FAILED;
-    boolean collide = false; // True if last slot nonempty
+  final int expandOrRetry(E e, @Var int h, int increment, @Var boolean wasUncontended) {
+    @Var int result = Buffer.FAILED;
+    @Var boolean collide = false; // True if last slot nonempty
     for (int attempt = 0; attempt < ATTEMPTS; attempt++) {
       Buffer<E>[] buffers;
       Buffer<E> buffer;
@@ -156,10 +159,11 @@ final int expandOrRetry(E e, int h, int increment, boolean wasUncontended) {
       if (((buffers = table) != null) && ((n = buffers.length) > 0)) {
         if ((buffer = buffers[(n - 1) & h]) == null) {
           if ((tableBusy == 0) && casTableBusy()) { // Try to attach new Buffer
-            boolean created = false;
+            @Var boolean created = false;
             try { // Recheck under lock
               Buffer<E>[] rs;
-              int mask, j;
+              int mask;
+              int j;
               if (((rs = table) != null) && ((mask = rs.length) > 0)
                   && (rs[j = (mask - 1) & h] == null)) {
                 rs[j] = create(e);
@@ -196,7 +200,7 @@ final int expandOrRetry(E e, int h, int increment, boolean wasUncontended) {
         }
         h += increment;
       } else if ((tableBusy == 0) && (table == buffers) && casTableBusy()) {
-        boolean init = false;
+        @Var boolean init = false;
         try { // Initialize table
           if (table == buffers) {
             @SuppressWarnings({"rawtypes", "unchecked"})
@@ -236,7 +240,7 @@ public long reads() {
     if (buffers == null) {
       return 0;
     }
-    long reads = 0;
+    @Var long reads = 0;
     for (Buffer<E> buffer : buffers) {
       if (buffer != null) {
         reads += buffer.reads();
@@ -251,7 +255,7 @@ public long writes() {
     if (buffers == null) {
       return 0;
     }
-    long writes = 0;
+    @Var long writes = 0;
     for (Buffer<E> buffer : buffers) {
       if (buffer != null) {
         writes += buffer.writes();
@@ -261,7 +265,7 @@ public long writes() {
   }
 
   /** Computes Stafford variant 13 of 64-bit mix function. */
-  static long mix64(long z) {
+  static long mix64(@Var long z) {
     z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
     z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
     return z ^ (z >>> 31);
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/TimerWheel.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/TimerWheel.java
index bb6aa3ee6b..df9911920b 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/TimerWheel.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/TimerWheel.java
@@ -25,6 +25,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A hierarchical timer wheel to add, remove, and fire expiration events in amortized O(1) time. The
  * expiration events are deferred until the timer is advanced, which is performed as part of the
@@ -86,8 +88,8 @@ final class TimerWheel<K, V> implements Iterable<Node<K, V>> {
    * @param currentTimeNanos the current time, in nanoseconds
    */
   @SuppressWarnings("PMD.UnusedAssignment")
-  public void advance(BoundedLocalCache<K, V> cache, long currentTimeNanos) {
-    long previousTimeNanos = nanos;
+  public void advance(BoundedLocalCache<K, V> cache, @Var long currentTimeNanos) {
+    @Var long previousTimeNanos = nanos;
     nanos = currentTimeNanos;
 
     // If wrapping then temporarily shift the clock for a positive comparison. We assume that the
@@ -122,6 +124,7 @@ public void advance(BoundedLocalCache<K, V> cache, long currentTimeNanos) {
    * @param previousTicks the previous number of ticks
    * @param delta the number of additional ticks
    */
+  @SuppressWarnings("Varifier")
   void expire(BoundedLocalCache<K, V> cache, int index, long previousTicks, long delta) {
     Node<K, V>[] timerWheel = wheel[index];
     int mask = timerWheel.length - 1;
@@ -135,7 +138,7 @@ void expire(BoundedLocalCache<K, V> cache, int index, long previousTicks, long d
     for (int i = start; i < end; i++) {
       Node<K, V> sentinel = timerWheel[i & mask];
       Node<K, V> prev = sentinel.getPreviousInVariableOrder();
-      Node<K, V> node = sentinel.getNextInVariableOrder();
+      @Var Node<K, V> node = sentinel.getNextInVariableOrder();
       sentinel.setPreviousInVariableOrder(sentinel);
       sentinel.setNextInVariableOrder(sentinel);
 
@@ -200,6 +203,7 @@ public void deschedule(Node<K, V> node) {
    * @param time the time when the event fires
    * @return the sentinel at the head of the bucket
    */
+  @SuppressWarnings("Varifier")
   Node<K, V> findBucket(long time) {
     long duration = time - nanos;
     int length = wheel.length - 1;
@@ -233,7 +237,7 @@ void unlink(Node<K, V> node) {
   }
 
   /** Returns the duration until the next bucket expires, or {@link Long#MAX_VALUE} if none. */
-  @SuppressWarnings("IntLongMath")
+  @SuppressWarnings({"IntLongMath", "Varifier"})
   public long getExpirationDelay() {
     for (int i = 0; i < SHIFT.length; i++) {
       Node<K, V>[] timerWheel = wheel[i];
@@ -250,7 +254,7 @@ public long getExpirationDelay() {
           continue;
         }
         long buckets = (j - start);
-        long delay = (buckets << SHIFT[i]) - (nanos & spanMask);
+        @Var long delay = (buckets << SHIFT[i]) - (nanos & spanMask);
         delay = (delay > 0) ? delay : SPANS[i];
 
         for (int k = i + 1; k < SHIFT.length; k++) {
@@ -269,6 +273,7 @@ public long getExpirationDelay() {
    *
    * @param index the timing wheel being operated on
    */
+  @SuppressWarnings("Varifier")
   long peekAhead(int index) {
     long ticks = (nanos >>> SHIFT[index]);
     Node<K, V>[] timerWheel = wheel[index];
@@ -336,7 +341,7 @@ public Node<K, V> next() {
     }
 
     @Nullable Node<K, V> computeNext() {
-      var node = (current == null) ? sentinel() : current;
+      @Var var node = (current == null) ? sentinel() : current;
       for (;;) {
         node = traverse(node);
         if (node != sentinel()) {
@@ -392,6 +397,7 @@ final class AscendingIterator extends Traverser {
       return wheel[wheelIndex][bucketIndex()];
     }
     int bucketIndex() {
+      @SuppressWarnings("Varifier")
       int ticks = (int) (nanos >>> SHIFT[wheelIndex]);
       int bucketMask = wheel[wheelIndex].length - 1;
       int bucketOffset = (ticks & bucketMask) + 1;
@@ -428,6 +434,7 @@ final class DescendingIterator extends Traverser {
       return node.getPreviousInVariableOrder();
     }
     int bucketIndex() {
+      @SuppressWarnings("Varifier")
       int ticks = (int) (nanos >>> SHIFT[wheelIndex]);
       int bucketMask = wheel[wheelIndex].length - 1;
       int bucketOffset = (ticks & bucketMask);
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/UnboundedLocalCache.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/UnboundedLocalCache.java
index 798b770a6d..0170a5ac42 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/UnboundedLocalCache.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/UnboundedLocalCache.java
@@ -54,6 +54,7 @@
 
 import com.github.benmanes.caffeine.cache.stats.StatsCounter;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * An in-memory cache that has no capabilities for bounding the map. This implementation provides
@@ -66,7 +67,7 @@ final class UnboundedLocalCache<K, V> implements LocalCache<K, V> {
   static final Logger logger = System.getLogger(UnboundedLocalCache.class.getName());
   static final VarHandle REFRESHES;
 
-  @Nullable final RemovalListener<K, V> removalListener;
+  final @Nullable RemovalListener<K, V> removalListener;
   final ConcurrentHashMap<K, V> data;
   final StatsCounter statsCounter;
   final boolean isRecordingStats;
@@ -76,7 +77,7 @@ final class UnboundedLocalCache<K, V> implements LocalCache<K, V> {
   @Nullable Set<K> keySet;
   @Nullable Collection<V> values;
   @Nullable Set<Entry<K, V>> entrySet;
-  @Nullable volatile ConcurrentMap<Object, CompletableFuture<?>> refreshes;
+  volatile @Nullable ConcurrentMap<Object, CompletableFuture<?>> refreshes;
 
   UnboundedLocalCache(Caffeine<? super K, ? super V> builder, boolean isAsync) {
     this.data = new ConcurrentHashMap<>(builder.getInitialCapacity());
@@ -103,7 +104,7 @@ public boolean isAsync() {
 
   @Override
   @SuppressWarnings("NullAway")
-  public Expiry<K, V> expiry() {
+  public @Nullable Expiry<K, V> expiry() {
     return null;
   }
 
@@ -215,7 +216,7 @@ public Executor executor() {
   @Override
   @SuppressWarnings("NullAway")
   public ConcurrentMap<Object, CompletableFuture<?>> refreshes() {
-    var pending = refreshes;
+    @Var var pending = refreshes;
     if (pending == null) {
       pending = new ConcurrentHashMap<>();
       if (!REFRESHES.compareAndSet(this, null, pending)) {
@@ -251,9 +252,9 @@ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
 
     // ensures that the removal notification is processed after the removal has completed
     @SuppressWarnings({"rawtypes", "unchecked"})
-    K[] notificationKey = (K[]) new Object[1];
+    var notificationKey = (K[]) new Object[1];
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] notificationValue = (V[]) new Object[1];
+    var notificationValue = (V[]) new Object[1];
     data.replaceAll((key, value) -> {
       if (notificationKey[0] != null) {
         notifyRemoval(notificationKey[0], notificationValue[0], RemovalCause.REPLACED);
@@ -280,7 +281,7 @@ public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction
     requireNonNull(mappingFunction);
 
     // optimistic fast path due to computeIfAbsent always locking
-    V value = data.get(key);
+    @Var V value = data.get(key);
     if (value != null) {
       if (recordStats) {
         statsCounter.recordHits(1);
@@ -314,11 +315,11 @@ public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction
 
     // ensures that the removal notification is processed after the removal has completed
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     boolean[] replaced = new boolean[1];
     V nv = data.computeIfPresent(key, (K k, V value) -> {
       BiFunction<? super K, ? super V, ? extends V> function = statsAware(remappingFunction,
-          /* recordLoad */ true, /* recordLoadFailure */ true);
+          /* recordLoad= */ true, /* recordLoadFailure= */ true);
       V newValue = function.apply(k, value);
 
       replaced[0] = (newValue != null);
@@ -364,7 +365,7 @@ public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> rem
   V remap(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
     // ensures that the removal notification is processed after the removal has completed
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     boolean[] replaced = new boolean[1];
     V nv = data.compute(key, (K k, V value) -> {
       V newValue = remappingFunction.apply(k, value);
@@ -423,7 +424,7 @@ public boolean containsValue(Object value) {
 
   @Override
   public @Nullable V get(Object key) {
-    return getIfPresent(key, /* recordStats */ false);
+    return getIfPresent(key, /* recordStats= */ false);
   }
 
   @Override
@@ -450,9 +451,9 @@ public void putAll(Map<? extends K, ? extends V> map) {
   @Override
   public @Nullable V remove(Object key) {
     @SuppressWarnings("unchecked")
-    K castKey = (K) key;
+    var castKey = (K) key;
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     data.computeIfPresent(castKey, (k, v) -> {
       discardRefresh(k);
       oldValue[0] = v;
@@ -474,9 +475,9 @@ public boolean remove(Object key, Object value) {
     }
 
     @SuppressWarnings("unchecked")
-    K castKey = (K) key;
+    var castKey = (K) key;
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
 
     data.computeIfPresent(castKey, (k, v) -> {
       if (v.equals(value)) {
@@ -499,7 +500,7 @@ public boolean remove(Object key, Object value) {
     requireNonNull(value);
 
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] oldValue = (V[]) new Object[1];
+    var oldValue = (V[]) new Object[1];
     data.computeIfPresent(key, (k, v) -> {
       discardRefresh(k);
       oldValue[0] = v;
@@ -514,7 +515,7 @@ public boolean remove(Object key, Object value) {
 
   @Override
   public boolean replace(K key, V oldValue, V newValue) {
-    return replace(key, oldValue, newValue, /* shouldDiscardRefresh */ true);
+    return replace(key, oldValue, newValue, /* shouldDiscardRefresh= */ true);
   }
 
   @Override
@@ -523,7 +524,7 @@ public boolean replace(K key, V oldValue, V newValue, boolean shouldDiscardRefre
     requireNonNull(newValue);
 
     @SuppressWarnings({"rawtypes", "unchecked"})
-    V[] prev = (V[]) new Object[1];
+    var prev = (V[]) new Object[1];
     data.computeIfPresent(key, (k, v) -> {
       if (v.equals(oldValue)) {
         if (shouldDiscardRefresh) {
@@ -569,19 +570,19 @@ public String toString() {
 
   @Override
   public Set<K> keySet() {
-    final Set<K> ks = keySet;
+    Set<K> ks = keySet;
     return (ks == null) ? (keySet = new KeySetView<>(this)) : ks;
   }
 
   @Override
   public Collection<V> values() {
-    final Collection<V> vs = values;
+    Collection<V> vs = values;
     return (vs == null) ? (values = new ValuesView<>(this)) : vs;
   }
 
   @Override
   public Set<Entry<K, V>> entrySet() {
-    final Set<Entry<K, V>> es = entrySet;
+    Set<Entry<K, V>> es = entrySet;
     return (es == null) ? (entrySet = new EntrySetView<>(this)) : es;
   }
 
@@ -617,7 +618,7 @@ public boolean contains(Object o) {
     @Override
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       if ((collection instanceof Set<?>) && (collection.size() > size())) {
         for (K key : this) {
           if (collection.contains(key)) {
@@ -640,7 +641,7 @@ public boolean remove(Object o) {
     @Override
     public boolean removeIf(Predicate<? super K> filter) {
       requireNonNull(filter);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (K key : this) {
         if (filter.test(key) && remove(key)) {
           modified = true;
@@ -652,7 +653,7 @@ public boolean removeIf(Predicate<? super K> filter) {
     @Override
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (K key : this) {
         if (!collection.contains(key) && remove(key)) {
           modified = true;
@@ -741,7 +742,7 @@ public boolean contains(Object o) {
     @Override
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var entry : cache.data.entrySet()) {
         if (collection.contains(entry.getValue())
             && cache.remove(entry.getKey(), entry.getValue())) {
@@ -767,7 +768,7 @@ public boolean remove(Object o) {
     @Override
     public boolean removeIf(Predicate<? super V> filter) {
       requireNonNull(filter);
-      boolean removed = false;
+      @Var boolean removed = false;
       for (var entry : cache.data.entrySet()) {
         if (filter.test(entry.getValue())) {
           removed |= cache.remove(entry.getKey(), entry.getValue());
@@ -779,7 +780,7 @@ public boolean removeIf(Predicate<? super V> filter) {
     @Override
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var entry : cache.data.entrySet()) {
         if (!collection.contains(entry.getValue())
             && cache.remove(entry.getKey(), entry.getValue())) {
@@ -879,7 +880,7 @@ public boolean contains(Object o) {
     @Override
     public boolean removeAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       if ((collection instanceof Set<?>) && (collection.size() > size())) {
         for (var entry : this) {
           if (collection.contains(entry)) {
@@ -908,7 +909,7 @@ public boolean remove(Object o) {
     @Override
     public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
       requireNonNull(filter);
-      boolean removed = false;
+      @Var boolean removed = false;
       for (var entry : cache.data.entrySet()) {
         if (filter.test(entry)) {
           removed |= cache.remove(entry.getKey(), entry.getValue());
@@ -920,7 +921,7 @@ public boolean removeIf(Predicate<? super Entry<K, V>> filter) {
     @Override
     public boolean retainAll(Collection<?> collection) {
       requireNonNull(collection);
-      boolean modified = false;
+      @Var boolean modified = false;
       for (var entry : this) {
         if (!collection.contains(entry) && remove(entry)) {
           modified = true;
@@ -1030,7 +1031,7 @@ static class UnboundedLocalManualCache<K, V> implements LocalManualCache<K, V>,
     @Nullable Policy<K, V> policy;
 
     UnboundedLocalManualCache(Caffeine<K, V> builder) {
-      cache = new UnboundedLocalCache<>(builder, /* async */ false);
+      cache = new UnboundedLocalCache<>(builder, /* isAsync= */ false);
     }
 
     @Override
@@ -1050,14 +1051,14 @@ private void readObject(ObjectInputStream stream) throws InvalidObjectException
     }
 
     Object writeReplace() {
-      SerializationProxy<K, V> proxy = new SerializationProxy<>();
+      var proxy = new SerializationProxy<K, V>();
       proxy.isRecordingStats = cache.isRecordingStats;
       proxy.removalListener = cache.removalListener;
       return proxy;
     }
   }
 
-  /** An eviction policy that supports no boundings. */
+  /** An eviction policy that supports no bounding. */
   static final class UnboundedPolicy<K, V> implements Policy<K, V> {
     final UnboundedLocalCache<K, V> cache;
     final Function<V, V> transformer;
@@ -1113,7 +1114,7 @@ static final class UnboundedLocalLoadingCache<K, V> extends UnboundedLocalManual
 
     final Function<K, V> mappingFunction;
     final CacheLoader<? super K, V> cacheLoader;
-    @Nullable final Function<Set<? extends K>, Map<K, V>> bulkMappingFunction;
+    final @Nullable Function<Set<? extends K>, Map<K, V>> bulkMappingFunction;
 
     UnboundedLocalLoadingCache(Caffeine<K, V> builder, CacheLoader<? super K, V> cacheLoader) {
       super(builder);
@@ -1164,7 +1165,7 @@ static final class UnboundedLocalAsyncCache<K, V> implements LocalAsyncCache<K,
     @SuppressWarnings("unchecked")
     UnboundedLocalAsyncCache(Caffeine<K, V> builder) {
       cache = new UnboundedLocalCache<>(
-          (Caffeine<K, CompletableFuture<V>>) builder, /* async */ true);
+          (Caffeine<K, CompletableFuture<V>>) builder, /* isAsync= */ true);
     }
 
     @Override
@@ -1185,10 +1186,10 @@ public Cache<K, V> synchronous() {
     @Override
     public Policy<K, V> policy() {
       @SuppressWarnings("unchecked")
-      UnboundedLocalCache<K, V> castCache = (UnboundedLocalCache<K, V>) cache;
+      var castCache = (UnboundedLocalCache<K, V>) cache;
       Function<CompletableFuture<V>, V> transformer = Async::getIfReady;
       @SuppressWarnings("unchecked")
-      Function<V, V> castTransformer = (Function<V, V>) transformer;
+      var castTransformer = (Function<V, V>) transformer;
       return (policy == null)
           ? (policy = new UnboundedPolicy<>(castCache, castTransformer))
           : policy;
@@ -1199,7 +1200,7 @@ private void readObject(ObjectInputStream stream) throws InvalidObjectException
     }
 
     Object writeReplace() {
-      SerializationProxy<K, V> proxy = new SerializationProxy<>();
+      var proxy = new SerializationProxy<K, V>();
       proxy.isRecordingStats = cache.isRecordingStats;
       proxy.removalListener = cache.removalListener;
       proxy.async = true;
@@ -1222,7 +1223,7 @@ static final class UnboundedLocalAsyncLoadingCache<K, V>
     UnboundedLocalAsyncLoadingCache(Caffeine<K, V> builder, AsyncCacheLoader<? super K, V> loader) {
       super(loader);
       cache = new UnboundedLocalCache<>(
-          (Caffeine<K, CompletableFuture<V>>) builder, /* async */ true);
+          (Caffeine<K, CompletableFuture<V>>) builder, /* isAsync= */ true);
     }
 
     @Override
@@ -1238,10 +1239,10 @@ public ConcurrentMap<K, CompletableFuture<V>> asMap() {
     @Override
     public Policy<K, V> policy() {
       @SuppressWarnings("unchecked")
-      UnboundedLocalCache<K, V> castCache = (UnboundedLocalCache<K, V>) cache;
+      var castCache = (UnboundedLocalCache<K, V>) cache;
       Function<CompletableFuture<V>, V> transformer = Async::getIfReady;
       @SuppressWarnings("unchecked")
-      Function<V, V> castTransformer = (Function<V, V>) transformer;
+      var castTransformer = (Function<V, V>) transformer;
       return (policy == null)
           ? (policy = new UnboundedPolicy<>(castCache, castTransformer))
           : policy;
@@ -1252,7 +1253,7 @@ private void readObject(ObjectInputStream stream) throws InvalidObjectException
     }
 
     Object writeReplace() {
-      SerializationProxy<K, V> proxy = new SerializationProxy<>();
+      var proxy = new SerializationProxy<K, V>();
       proxy.isRecordingStats = cache.isRecordingStats();
       proxy.removalListener = cache.removalListener;
       proxy.cacheLoader = cacheLoader;
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Weigher.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Weigher.java
index 6ebb447482..8b7cac4561 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Weigher.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/Weigher.java
@@ -53,7 +53,7 @@ public interface Weigher<K, V> {
    */
   static <K, V> Weigher<K, V> singletonWeigher() {
     @SuppressWarnings("unchecked")
-    Weigher<K, V> instance = (Weigher<K, V>) SingletonWeigher.INSTANCE;
+    var instance = (Weigher<K, V>) SingletonWeigher.INSTANCE;
     return instance;
   }
 
diff --git a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/stats/CacheStats.java b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/stats/CacheStats.java
index c1afc4d022..d22feda6d8 100644
--- a/caffeine/src/main/java/com/github/benmanes/caffeine/cache/stats/CacheStats.java
+++ b/caffeine/src/main/java/com/github/benmanes/caffeine/cache/stats/CacheStats.java
@@ -357,7 +357,7 @@ public boolean equals(@Nullable Object o) {
     } else if (!(o instanceof CacheStats)) {
       return false;
     }
-    CacheStats other = (CacheStats) o;
+    var other = (CacheStats) o;
     return hitCount == other.hitCount
         && missCount == other.missCount
         && loadSuccessCount == other.loadSuccessCount
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedBufferTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedBufferTest.java
index e108d90eb6..79114b8892 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedBufferTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedBufferTest.java
@@ -98,4 +98,11 @@ public void overflow() {
     assertThat(buffer.readCounter).isEqualTo(Long.MIN_VALUE);
     assertThat(buffer.writeCounter).isEqualTo(Long.MIN_VALUE);
   }
+
+  @Test
+  public void reflectivelyConstruct() throws ReflectiveOperationException {
+    var constructor = BBHeader.class.getDeclaredConstructor();
+    constructor.setAccessible(true);
+    constructor.newInstance();
+  }
 }
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedLocalCacheTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedLocalCacheTest.java
index 9ef151b8a1..d2a28dd6a2 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedLocalCacheTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/BoundedLocalCacheTest.java
@@ -238,7 +238,7 @@ public void clear_pendingWrites_weakKeys(
   @Test
   public void cleanupTask_allowGc() {
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder(), /* loader */ null, /* async */ false) {};
+        Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false) {};
     var task = cache.drainBuffersTask;
     cache = null;
 
@@ -282,7 +282,7 @@ public void cleanup_exception() {
   @Test
   public void scheduleAfterWrite() {
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder(), /* loader */ null, /* async */ false) {
+        Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false) {
       @Override void scheduleDrainBuffers() {}
     };
     var transitions = Map.of(
@@ -300,7 +300,7 @@ public void scheduleAfterWrite() {
   @Test
   public void scheduleAfterWrite_invalidDrainStatus() {
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder(), /* loader */ null, /* async */ false) {};
+        Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false) {};
     var valid = Set.of(IDLE, REQUIRED, PROCESSING_TO_IDLE, PROCESSING_TO_REQUIRED);
     var invalid = IntStream.generate(ThreadLocalRandom.current()::nextInt).boxed()
         .filter(Predicate.not(valid::contains))
@@ -314,7 +314,7 @@ public void scheduleAfterWrite_invalidDrainStatus() {
   public void scheduleDrainBuffers() {
     Executor executor = Mockito.mock();
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder().executor(executor), /* loader */ null, /* async */ false) {};
+        Caffeine.newBuilder().executor(executor), /* cacheLoader */ null, /* isAsync */ false) {};
     var transitions = Map.of(
         IDLE, PROCESSING_TO_IDLE,
         REQUIRED, PROCESSING_TO_IDLE,
@@ -377,7 +377,7 @@ public void scheduleDrainBuffers_rejected(
   @Test
   public void shouldDrainBuffers_invalidDrainStatus() {
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder(), /* loader */ null, /* async */ false) {};
+        Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false) {};
     var valid = Set.of(IDLE, REQUIRED, PROCESSING_TO_IDLE, PROCESSING_TO_REQUIRED);
     var invalid = IntStream.generate(ThreadLocalRandom.current()::nextInt).boxed()
         .filter(Predicate.not(valid::contains))
@@ -543,7 +543,7 @@ public void afterWrite_drainFullWriteBuffer_discarded(
   public void afterWrite_exception() {
     var expected = new RuntimeException();
     var cache = new BoundedLocalCache<Object, Object>(
-        Caffeine.newBuilder(), /* loader */ null, /* async */ false) {
+        Caffeine.newBuilder(), /* cacheLoader */ null, /* isAsync */ false) {
       @Override void maintenance(Runnable task) {
         throw expected;
       }
@@ -750,19 +750,19 @@ public void evict_wtinylfu(Cache<Int, Int> cache, CacheContext context) {
         /* expect */ Int.listOf(9, 0, 1, 2, 3, 4, 5, 6, 7, 8));
 
     // re-order
-    checkReorder(cache, /* keys */ Int.listOf(0, 1, 2),
+    checkReorder(cache, /* keys= */ Int.listOf(0, 1, 2),
         /* expect */ Int.listOf(9, 3, 4, 5, 6, 7, 8, 0, 1, 2));
 
     // evict 9, 10, 11
-    checkEvict(cache, /* keys */ Int.listOf(10, 11, 12),
+    checkEvict(cache, /* keys= */ Int.listOf(10, 11, 12),
         /* expect */ Int.listOf(12, 3, 4, 5, 6, 7, 8, 0, 1, 2));
 
     // re-order
-    checkReorder(cache, /* keys */ Int.listOf(6, 7, 8),
+    checkReorder(cache, /* keys= */ Int.listOf(6, 7, 8),
         /* expect */ Int.listOf(12, 3, 4, 5, 0, 1, 2, 6, 7, 8));
 
     // evict 12, 13, 14
-    checkEvict(cache, /* keys */ Int.listOf(13, 14, 15),
+    checkEvict(cache, /* keys= */ Int.listOf(13, 14, 15),
         /* expect */ Int.listOf(15, 3, 4, 5, 0, 1, 2, 6, 7, 8));
 
     assertThat(context).stats().evictions(6);
@@ -1584,7 +1584,7 @@ public void exceedsMaximumBufferSize_onRead(
     var result = buffer.offer(dummy);
     assertThat(result).isEqualTo(Buffer.FULL);
 
-    var refreshed = cache.afterRead(dummy, 0, /* recordHit */ true);
+    var refreshed = cache.afterRead(dummy, /* now= */ 0, /* recordHit= */ true);
     assertThat(refreshed).isNull();
 
     result = buffer.offer(dummy);
@@ -1736,7 +1736,7 @@ void checkDrainBlocks(BoundedLocalCache<Int, Int> cache, Runnable task) {
   @CacheSpec(compute = Compute.SYNC, population = Population.FULL,
       maximumSize = Maximum.FULL, weigher = {CacheWeigher.DISABLED, CacheWeigher.TEN})
   public void adapt_increaseWindow(BoundedLocalCache<Int, Int> cache, CacheContext context) {
-    prepareForAdaption(cache, context, /* make frequency-bias */ false);
+    prepareForAdaption(cache, context, /* recencyBias= */ false);
 
     int sampleSize = cache.frequencySketch().sampleSize;
     long protectedSize = cache.mainProtectedWeightedSize();
@@ -1756,7 +1756,7 @@ public void adapt_increaseWindow(BoundedLocalCache<Int, Int> cache, CacheContext
   @CacheSpec(compute = Compute.SYNC, population = Population.FULL,
       maximumSize = Maximum.FULL, weigher = {CacheWeigher.DISABLED, CacheWeigher.TEN})
   public void adapt_decreaseWindow(BoundedLocalCache<Int, Int> cache, CacheContext context) {
-    prepareForAdaption(cache, context, /* make recency-bias */ true);
+    prepareForAdaption(cache, context, /* recencyBias= */ true);
 
     int sampleSize = cache.frequencySketch().sampleSize;
     long protectedSize = cache.mainProtectedWeightedSize();
@@ -2525,6 +2525,13 @@ private static void checkBrokenEqualityMessage(
 
   /* --------------- Miscellaneous --------------- */
 
+  @Test
+  public void reflectivelyConstruct() throws ReflectiveOperationException {
+    var constructor = BLCHeader.class.getDeclaredConstructor();
+    constructor.setAccessible(true);
+    constructor.newInstance();
+  }
+
   @Test
   public void cacheFactory_null() {
     assertThrows(NullPointerException.class,
@@ -2561,7 +2568,8 @@ public void cacheFactory_exception() throws Throwable {
       when(factory.newInstance(any(), any(), anyBoolean())).thenThrow(IOException.class);
       Caffeine<Object, Object> builder = Caffeine.newBuilder().weakKeys();
       var expected = assertThrows(IllegalStateException.class, () ->
-          LocalCacheFactory.newBoundedLocalCache(builder, /* loader */ null, false));
+          LocalCacheFactory.newBoundedLocalCache(builder,
+              /* cacheLoader */ null, /* isAsync */ false));
       assertThat(expected).hasCauseThat().isInstanceOf(IOException.class);
     } finally {
       LocalCacheFactory.FACTORIES.clear();
@@ -2576,8 +2584,8 @@ public void cacheFactory_error() throws Throwable {
 
       Caffeine<Object, Object> builder = Caffeine.newBuilder().weakKeys();
       when(factory.newInstance(any(), any(), anyBoolean())).thenThrow(Error.class);
-      assertThrows(Error.class, () ->
-          LocalCacheFactory.newBoundedLocalCache(builder, /* loader */ null, false));
+      assertThrows(Error.class, () -> LocalCacheFactory.newBoundedLocalCache(
+          builder, /* cacheLoader */ null, /* isAsync */ false));
     } finally {
       LocalCacheFactory.FACTORIES.clear();
     }
@@ -2587,7 +2595,8 @@ public void cacheFactory_error() throws Throwable {
   public void cacheFactory_noStaticFactory() throws Throwable {
     var factory = LocalCacheFactory.loadFactory("BoundedLocalCacheTest$CustomBoundedLocalCache");
     assertThat(factory).isInstanceOf(MethodHandleBasedFactory.class);
-    var cache = factory.newInstance(Caffeine.newBuilder(), /* loader */ null, false);
+    var cache = factory.newInstance(Caffeine.newBuilder(),
+        /* cacheLoader */ null, /* isAsync */ false);
     assertThat(cache).isInstanceOf(CustomBoundedLocalCache.class);
   }
 
@@ -2596,7 +2605,8 @@ public void cacheFactory_noStaticFactory() throws Throwable {
   public void cacheFactory_loadFactory(
       BoundedLocalCache<Int, Int> cache, CacheContext context) throws Throwable {
     var factory1 = LocalCacheFactory.loadFactory(cache.getClass().getSimpleName());
-    var other = factory1.newInstance(context.caffeine(), /* cacheLoader */ null, context.isAsync());
+    var other = factory1.newInstance(context.caffeine(),
+        /* cacheLoader= */ null, context.isAsync());
     assertThat(other.getClass()).isEqualTo(cache.getClass());
     assertThat(LocalCacheFactory.FACTORIES).containsEntry(
         cache.getClass().getSimpleName(), factory1);
@@ -2614,9 +2624,9 @@ public void cacheFactory_byMethodHandle(
     assertThat(methodHandleFactory).isNotSameInstanceAs(staticFactory);
 
     var c1 = methodHandleFactory.newInstance(
-        context.caffeine(), /* cacheLoader */ null, context.isAsync());
+        context.caffeine(), /* cacheLoader= */ null, context.isAsync());
     var c2 = staticFactory.newInstance(
-        context.caffeine(), /* cacheLoader */ null, context.isAsync());
+        context.caffeine(), /* cacheLoader= */ null, context.isAsync());
     assertThat(c1.getClass()).isEqualTo(c2.getClass());
   }
 
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/InternerTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/InternerTest.java
index e614bb9a95..35142b515f 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/InternerTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/InternerTest.java
@@ -149,7 +149,7 @@ public void factory() {
     var builder = Caffeine.newBuilder();
     builder.interner = true;
 
-    var factory = NodeFactory.newFactory(builder, /* async */ false);
+    var factory = NodeFactory.newFactory(builder, /* isAsync= */ false);
     assertThat(factory).isSameInstanceAs(Interned.FACTORY);
   }
 
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueueTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueueTest.java
index 05d976c33f..e2beda0281 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueueTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MpscGrowableArrayQueueTest.java
@@ -43,24 +43,24 @@ public final class MpscGrowableArrayQueueTest {
   @Test
   public void constructor_initialCapacity_tooSmall() {
     assertThrows(IllegalArgumentException.class, () ->
-        new MpscGrowableArrayQueue<Integer>(/* initialCapacity */ 1, /* maxCapacity */ 4));
+        new MpscGrowableArrayQueue<Integer>(/* initialCapacity= */ 1, /* maxCapacity= */ 4));
   }
 
   @Test
   public void constructor_maxCapacity_tooSmall() {
     assertThrows(IllegalArgumentException.class, () ->
-        new MpscGrowableArrayQueue<Integer>(/* initialCapacity */ 4, /* maxCapacity */ 1));
+        new MpscGrowableArrayQueue<Integer>(/* initialCapacity= */ 4, /* maxCapacity= */ 1));
   }
 
   @Test
   public void constructor_inverted() {
     assertThrows(IllegalArgumentException.class, () ->
-        new MpscGrowableArrayQueue<Integer>(/* initialCapacity */ 8, /* maxCapacity */ 4));
+        new MpscGrowableArrayQueue<Integer>(/* initialCapacity= */ 8, /* maxCapacity= */ 4));
   }
 
   @Test
   public void constructor() {
-    var queue = new MpscGrowableArrayQueue<Integer>(/* initialCapacity */ 4, /* maxCapacity */ 8);
+    var queue = new MpscGrowableArrayQueue<Integer>(/* initialCapacity= */ 4, /* maxCapacity= */ 8);
     assertThat(queue.capacity()).isEqualTo(8);
   }
 
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MultiThreadedTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MultiThreadedTest.java
index 7e5236ee17..dc92507e0b 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MultiThreadedTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/MultiThreadedTest.java
@@ -42,6 +42,7 @@
 import com.github.benmanes.caffeine.cache.testing.CheckMaxLogLevel;
 import com.github.benmanes.caffeine.testing.Int;
 import com.github.benmanes.caffeine.testing.Threads;
+import com.google.common.collect.ImmutableList;
 import com.google.common.testing.SerializableTester;
 
 /**
@@ -100,7 +101,7 @@ public void async_concurrent_bounded(
 
   @SuppressWarnings({"CollectionToArray", "FutureReturnValueIgnored", "MethodReferenceUsage",
     "rawtypes", "ReturnValueIgnored", "SelfEquals", "SizeGreaterThanOrEqualsZero"})
-  List<BiConsumer<LoadingCache<Int, Int>, Int>> operations = List.of(
+  ImmutableList<BiConsumer<LoadingCache<Int, Int>, Int>> operations = ImmutableList.of(
       // LoadingCache
       (cache, key) -> { cache.get(key); },
       (cache, key) -> { cache.getAll(List.of(key)); },
@@ -160,7 +161,7 @@ public void async_concurrent_bounded(
       });
 
   @SuppressWarnings({"CheckReturnValue", "FutureReturnValueIgnored", "MethodReferenceUsage"})
-  List<BiConsumer<AsyncLoadingCache<Int, Int>, Int>> asyncOperations = List.of(
+  ImmutableList<BiConsumer<AsyncLoadingCache<Int, Int>, Int>> asyncOperations = ImmutableList.of(
       (cache, key) -> { cache.getIfPresent(key); },
       (cache, key) -> { cache.get(key, k -> key); },
       (cache, key) -> { cache.get(key, (k, e) -> CompletableFuture.completedFuture(key)); },
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/QueueSanityTest.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/QueueSanityTest.java
index e3baffdc05..7ba9dc1548 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/QueueSanityTest.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/QueueSanityTest.java
@@ -24,6 +24,7 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeThat;
+import static org.testng.Assert.assertThrows;
 
 import java.util.Collection;
 import java.util.Queue;
@@ -134,9 +135,9 @@ public void whenFirstInThenFirstOut() {
     assertThat(i, is(size));
   }
 
-  @Test(expected = NullPointerException.class)
+  @Test
   public void offerNullResultsInNPE() {
-    queue.offer(null);
+    assertThrows(NullPointerException.class, () -> queue.offer(null));
   }
 
   @Test
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContext.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContext.java
index 0234c6e29c..f7d9d8e7a6 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContext.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContext.java
@@ -124,6 +124,7 @@ public final class CacheContext {
 
   Map<Int, Int> absent;
 
+  @SuppressWarnings("TooManyParameters")
   public CacheContext(InitialCapacity initialCapacity, Stats stats, CacheWeigher cacheWeigher,
       Maximum maximumSize, CacheExpiry expiryType, Expire afterAccess, Expire afterWrite,
       Expire refresh, ReferenceType keyStrength, ReferenceType valueStrength,
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContextSubject.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContextSubject.java
index 3e98bf232d..8ee8905408 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContextSubject.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheContextSubject.java
@@ -49,6 +49,7 @@
 import com.github.benmanes.caffeine.cache.testing.RemovalListeners.ConsumingRemovalListener;
 import com.github.benmanes.caffeine.testing.Int;
 import com.google.common.base.CaseFormat;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.Multimaps;
 import com.google.common.truth.FailureMetadata;
@@ -276,11 +277,11 @@ public static final class ListenerSubject extends Subject {
     static final Factory<ListenerSubject, CacheContext> LISTENERS_FACTORY =
         factoryOf(RemovalListenerType.values());
 
-    private final Map<RemovalListenerType, RemovalListener<Int, Int>> actual;
+    private final ImmutableMap<RemovalListenerType, RemovalListener<Int, Int>> actual;
     private final boolean isDirect;
 
     private ListenerSubject(FailureMetadata metadata, CacheContext context,
-        Map<RemovalListenerType, RemovalListener<Int, Int>> subject) {
+        ImmutableMap<RemovalListenerType, RemovalListener<Int, Int>> subject) {
       super(metadata, subject);
       this.actual = subject;
       this.isDirect = (context.executorType() == CacheExecutor.DIRECT);
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheGenerator.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheGenerator.java
index d72a3f1698..e6f83b2627 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheGenerator.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheGenerator.java
@@ -61,7 +61,7 @@ public final class CacheGenerator {
 
   public CacheGenerator(CacheSpec cacheSpec) {
     this(cacheSpec, Options.fromSystemProperties(),
-        /* isLoadingOnly */ false, /* isAsyncOnly */ false, /* isGuavaCompatible */ true);
+        /* isLoadingOnly= */ false, /* isAsyncOnly= */ false, /* isGuavaCompatible= */ true);
   }
 
   CacheGenerator(CacheSpec cacheSpec, Options options,
@@ -250,7 +250,7 @@ private static void populate(CacheContext context, Cache<Int, Int> cache) {
 
   /** Returns a cache of integers and their negation. */
   private static ImmutableList<Map.Entry<Int, Int>> makeInts() {
-    int size = Arrays.stream(CacheSpec.Population.values())
+    int size = Arrays.stream(Population.values())
         .mapToInt(population -> Math.toIntExact(population.size()))
         .max().getAsInt();
     var builder = new ImmutableList.Builder<Map.Entry<Int, Int>>();
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheSpec.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheSpec.java
index 847c8b9625..718f248f41 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheSpec.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/CacheSpec.java
@@ -195,18 +195,18 @@ enum CacheWeigher {
     /** A flag indicating that every entry is valued at Integer.MAX_VALUE units. */
     MAX_VALUE(Integer.MAX_VALUE),
     /** A flag indicating that the entry is weighted by the absolute integer value. */
-    VALUE(() -> (key, value) -> Math.abs(((Int) value).intValue()), 1),
+    VALUE(() -> (key, value) -> Math.abs(((Int) value).intValue())),
     /** A flag indicating that the entry is weighted by the value's collection size. */
-    COLLECTION(() -> (key, value) -> ((Collection<?>) value).size(), 1),
+    COLLECTION(() -> (key, value) -> ((Collection<?>) value).size()),
     /** A flag indicating that the entry's weight is randomly changing. */
-    RANDOM(Weighers::random, 1),
+    RANDOM(Weighers::random),
     /** A flag indicating that the entry's weight records interactions. */
     @SuppressWarnings("unchecked")
     MOCKITO(() -> {
       Weigher<Object, Object> weigher = Mockito.mock();
       when(weigher.weigh(any(), any())).thenReturn(1);
       return weigher;
-    }, 1);
+    });
 
     private final Supplier<Weigher<Object, Object>> factory;
     private final int units;
@@ -215,9 +215,9 @@ enum CacheWeigher {
       this.factory = () -> Weighers.constant(units);
       this.units = units;
     }
-    CacheWeigher(Supplier<Weigher<Object, Object>> factory, int units) {
+    CacheWeigher(Supplier<Weigher<Object, Object>> factory) {
       this.factory = factory;
-      this.units = units;
+      this.units = 1;
     }
     public int unitsPerEntry() {
       return units;
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/GuavaCacheFromContext.java b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/GuavaCacheFromContext.java
index 6272aeb884..9b5f2dfa0f 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/GuavaCacheFromContext.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/GuavaCacheFromContext.java
@@ -214,7 +214,7 @@ public Map<K, V> getAll(Iterable<? extends K> keys, Function<? super Set<? exten
         long end = ticker.read();
         statsCounter.recordLoadSuccess(end - start);
 
-        Map<K, V> result = new LinkedHashMap<>();
+        var result = new LinkedHashMap<K, V>();
         for (K key : keys) {
           V value = found.get(key);
           if (value == null) {
@@ -552,7 +552,7 @@ public CompletableFuture<V> refresh(K key) {
 
     @Override
     public CompletableFuture<Map<K, V>> refreshAll(Iterable<? extends K> keys) {
-      Map<K, CompletableFuture<V>> result = new LinkedHashMap<>();
+      var result = new LinkedHashMap<K, CompletableFuture<V>>();
       for (K key : keys) {
         result.computeIfAbsent(key, this::refresh);
       }
@@ -567,7 +567,7 @@ CompletableFuture<Map<K, V>> composeResult(Map<K, CompletableFuture<V>> futures)
       @SuppressWarnings("rawtypes")
       CompletableFuture<?>[] array = futures.values().toArray(new CompletableFuture[0]);
       return CompletableFuture.allOf(array).thenApply(ignored -> {
-        Map<K, V> result = new LinkedHashMap<>(futures.size());
+        var result = new LinkedHashMap<K, V>(futures.size());
         futures.forEach((key, future) -> {
           V value = future.getNow(null);
           if (value != null) {
@@ -703,7 +703,7 @@ static final class CacheMissException extends RuntimeException {
     private static final long serialVersionUID = 1L;
 
     CacheMissException() {
-      super(null, null, /* enableSuppression */ false, /* writableStackTrace */ false);
+      super(null, null, /* enableSuppression= */ false, /* writableStackTrace= */ false);
     }
   }
 }
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/jsr166/JSR166TestCase.java b/caffeine/src/test/java/com/github/benmanes/caffeine/jsr166/JSR166TestCase.java
index e06cb5ba94..0bce867d2a 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/jsr166/JSR166TestCase.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/jsr166/JSR166TestCase.java
@@ -245,7 +245,7 @@ private static float systemPropertyValue(String name) {
         } catch (NumberFormatException ex) {
             throw new IllegalArgumentException(
                 String.format(US, "Bad float value in system property %s=%s",
-                              name, floatString));
+                              name, floatString), ex);
         }
     }
 
@@ -622,6 +622,7 @@ public static List<String> testMethodNames(Class<?> testClass) {
      * Returns junit-style testSuite for the given test class, but
      * parameterized by passing extra data to each test.
      */
+    @SuppressWarnings("TypeParameterNaming")
     public static <ExtraData> Test parameterizedTestSuite
         (Class<? extends JSR166TestCase> testClass,
          Class<ExtraData> dataClass,
@@ -644,6 +645,7 @@ public static List<String> testMethodNames(Class<?> testClass) {
      * given test class, but parameterized by passing extra data to
      * each test.  Uses reflection to allow compilation in jdk7.
      */
+    @SuppressWarnings("TypeParameterNaming")
     public static <ExtraData> Test jdk8ParameterizedTestSuite
         (Class<? extends JSR166TestCase> testClass,
          Class<ExtraData> dataClass,
@@ -1959,7 +1961,7 @@ public int await() {
             try {
                 return super.await(LONGER_DELAY_MS, MILLISECONDS);
             } catch (TimeoutException timedOut) {
-                throw new AssertionError("timed out");
+                throw new AssertionError("timed out", timedOut);
             } catch (Exception fail) {
                 throw new AssertionError("Unexpected exception: " + fail, fail);
             }
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/LoggingEvents.java b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/LoggingEvents.java
index 1f1be4976f..28ea542dbc 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/LoggingEvents.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/LoggingEvents.java
@@ -40,13 +40,13 @@
  */
 public final class LoggingEvents extends ForwardingList<LoggingEvent> {
   private final List<Predicate<LoggingEvent>> predicates;
-  private final List<LoggingEvent> events;
+  private final ImmutableList<LoggingEvent> events;
 
   private ImmutableList<LoggingEvent> filteredEvents;
   private boolean exclusive;
 
   private LoggingEvents(List<LoggingEvent> events) {
-    this.events = requireNonNull(events);
+    this.events = ImmutableList.copyOf(events);
     this.predicates = new ArrayList<>();
   }
 
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/MapSubject.java b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/MapSubject.java
index 743a1103ee..32c767e4da 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/MapSubject.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/MapSubject.java
@@ -33,6 +33,7 @@
  * @author ben.manes@gmail.com (Ben Manes)
  */
 public class MapSubject extends com.google.common.truth.MapSubject {
+  @SuppressWarnings("ImmutableMemberCollection")
   private final Map<?, ?> actual;
 
   public MapSubject(FailureMetadata metadata, Map<?, ?> subject) {
diff --git a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/Threads.java b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/Threads.java
index e14e6f3c69..5fe6929fa7 100644
--- a/caffeine/src/test/java/com/github/benmanes/caffeine/testing/Threads.java
+++ b/caffeine/src/test/java/com/github/benmanes/caffeine/testing/Threads.java
@@ -40,6 +40,7 @@
 import org.slf4j.LoggerFactory;
 
 import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableList;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 
@@ -57,7 +58,7 @@ public final class Threads {
 
   private Threads() {}
 
-  public static <A> void runTest(A collection, List<BiConsumer<A, Int>> operations) {
+  public static <A> void runTest(A collection, ImmutableList<BiConsumer<A, Int>> operations) {
     var failures = new ConcurrentLinkedQueue<String>();
     var thrasher = new Thrasher<A>(collection, failures, operations);
     Threads.executeWithTimeOut(failures, () ->
@@ -98,7 +99,7 @@ public static void handleTimeout(Queue<String> failures, ExecutorService es, Tim
     fail("Spun forever", e);
   }
 
-  public static List<List<Int>> workingSets(int nThreads, int iterations) {
+  public static ImmutableList<ImmutableList<Int>> workingSets(int nThreads, int iterations) {
     var keys = IntStream.range(0, iterations)
         .map(i -> ThreadLocalRandom.current().nextInt(iterations / 100))
         .mapToObj(Int::valueOf)
@@ -112,25 +113,26 @@ public static List<List<Int>> workingSets(int nThreads, int iterations) {
    * @param samples the number of variants to create
    * @param baseline the base working set to build from
    */
-  private static <T> List<List<T>> shuffle(int samples, List<T> baseline) {
-    var workingSets = new ArrayList<List<T>>(samples);
+  private static <T> ImmutableList<ImmutableList<T>> shuffle(int samples, List<T> baseline) {
+    var workingSets = new ArrayList<ImmutableList<T>>(samples);
     var workingSet = new ArrayList<T>(baseline);
     for (int i = 0; i < samples; i++) {
       Collections.shuffle(workingSet);
-      workingSets.add(List.copyOf(workingSet));
+      workingSets.add(ImmutableList.copyOf(workingSet));
     }
-    return List.copyOf(workingSets);
+    return ImmutableList.copyOf(workingSets);
   }
 
   /** Executes operations against the cache to simulate random load. */
   public static final class Thrasher<A> implements Runnable {
-    private final List<BiConsumer<A, Int>> operations;
-    private final List<List<Int>> sets;
+    private final ImmutableList<BiConsumer<A, Int>> operations;
+    private final ImmutableList<ImmutableList<Int>> sets;
     private final Queue<String> failures;
     private final AtomicInteger index;
     private final A collection;
 
-    public Thrasher(A collection, Queue<String> failures, List<BiConsumer<A, Int>> operations) {
+    public Thrasher(A collection, Queue<String> failures,
+        ImmutableList<BiConsumer<A, Int>> operations) {
       this.sets = workingSets(Threads.NTHREADS, Threads.ITERATIONS);
       this.index = new AtomicInteger();
       this.operations = operations;
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c74537b1a0..65e5658be2 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -22,7 +22,7 @@ coveralls = "2.12.2"
 dependency-check = "10.0.4"
 eclipse-collections = "12.0.0.M3"
 ehcache3 = "3.10.8"
-errorprone = "2.31.0"
+errorprone = "2.32.0"
 errorprone-plugin = "4.0.1"
 errorprone-support = "0.18.0"
 expiring-map = "0.5.11"
@@ -53,7 +53,7 @@ jcache = "1.1.1"
 jcommander = "1.82"
 jctools = "4.0.5"
 jfreechart = "1.5.5"
-jgit = "6.10.0.202406032230-r"
+jgit = "7.0.0.202409031743-r"
 jmh = "1.37"
 jmh-plugin = "0.7.2"
 jmh-report = "0.9.6"
@@ -65,13 +65,13 @@ junit4 = "4.13.2"
 junit5 = "5.11.0"
 jvm-dependency-conflict-resolution = "2.1.2"
 kotlin = "2.0.20"
-lincheck = "2.33"
+lincheck = "2.34"
 mockito = "5.13.0"
 nexus-publish = "2.0.0"
 nullaway = "0.11.2"
 nullaway-plugin = "2.0.0"
 okhttp-bom = "4.12.0"
-okio-bom = "3.9.0"
+okio-bom = "3.9.1"
 osgi-annotations = "1.5.1"
 osgi-function = "1.2.0"
 osgi-promise = "1.3.0"
@@ -79,7 +79,7 @@ pax-exam = "4.13.5"
 pax-url = "2.6.14"
 picocli = "4.7.6"
 pmd = "7.5.0"
-protobuf = "4.28.0"
+protobuf = "4.28.1"
 slf4j = "2.0.16"
 slf4j-test = "3.0.1"
 snakeyaml = "2.3"
diff --git a/gradle/plugins/src/main/kotlin/lifecycle/java-library.caffeine.gradle.kts b/gradle/plugins/src/main/kotlin/lifecycle/java-library.caffeine.gradle.kts
index 667f0a4f6b..9f9ceff855 100644
--- a/gradle/plugins/src/main/kotlin/lifecycle/java-library.caffeine.gradle.kts
+++ b/gradle/plugins/src/main/kotlin/lifecycle/java-library.caffeine.gradle.kts
@@ -32,7 +32,8 @@ tasks.withType<JavaCompile>().configureEach {
   }
 
   options.compilerArgs.addAll(listOf("-Xlint:all", "-Xlint:-auxiliaryclass", "-Xlint:-classfile",
-    "-Xlint:-exports", "-Xlint:-processing", "-Xlint:-removal", "-Xlint:-requires-automatic"))
+    "-Xlint:-exports", "-Xlint:-processing", "-Xlint:-removal", "-Xlint:-requires-automatic",
+     "-Xmaxerrs", "1000", "-Xmaxwarns", "1000"))
   if (javaVersion.canCompileOrRun(21)) {
     options.compilerArgs.add("-proc:full")
   }
diff --git a/gradle/plugins/src/main/kotlin/quality/errorprone.caffeine.gradle.kts b/gradle/plugins/src/main/kotlin/quality/errorprone.caffeine.gradle.kts
index a19854b573..df02aed1d5 100644
--- a/gradle/plugins/src/main/kotlin/quality/errorprone.caffeine.gradle.kts
+++ b/gradle/plugins/src/main/kotlin/quality/errorprone.caffeine.gradle.kts
@@ -48,6 +48,7 @@ tasks.withType<JavaCompile>().configureEach {
     if (System.getenv("JDK_EA") == "true") {
       isEnabled = false
     }
+    allDisabledChecksAsWarnings = true
 
     errorproneArgs.add(buildString {
       append("-XepOpt:Refaster:NamePattern=^")
@@ -59,7 +60,6 @@ tasks.withType<JavaCompile>().configureEach {
       append(".*")
     })
     disabledChecks().forEach { disable(it) }
-    enabledChecks().forEach { enable(it) }
     errorChecks().forEach { error(it) }
 
     nullaway {
@@ -80,68 +80,17 @@ fun errorChecks() = listOf(
 )
 fun disabledChecks() = listOf(
   "AvoidObjectArrays",
+  "AndroidJdkLibsChecker",
   "IsInstanceLambdaUsage",
+  "Java7ApiChecker",
+  "Java8ApiChecker",
   "LexicographicalAnnotationListing",
   "MissingSummary",
+  "MultipleTopLevelClasses",
   "PatternMatchingInstanceof",
   "StaticImport",
-)
-fun enabledChecks() = listOf(
-  "AssertFalse",
-  "AutoValueBoxedValues",
-  "BanClassLoader",
-  "BuilderReturnThis",
-  "CatchingUnchecked",
-  "CanIgnoreReturnValueSuggester",
-  "CheckedExceptionNotThrown",
-  "ClassName",
-  "ComparisonContractViolated",
-  "CannotMockFinalClass",
-  "CannotMockFinalMethod",
-  "DefaultLocale",
-  "DepAnn",
-  "EmptyIf",
-  "EqualsBrokenForNull",
-  "FieldCanBeLocal",
-  "FieldCanBeStatic",
-  "ForEachIterable",
-  "FuzzyEqualsShouldNotBeUsedInEqualsMethod",
-  "FunctionalInterfaceClash",
-  "IterablePathParameter",
-  "LongLiteralLowerCaseSuffix",
-  "MissingBraces",
-  "MissingDefault",
-  "MixedArrayDimensions",
-  "MissingDefault",
-  "MissingRuntimeRetention",
-  "MockitoDoSetup",
-  "MutableGuiceModule",
-  "NoAllocation",
-  "NonFinalStaticField",
-  "OverridingMethodInconsistentArgumentNamesChecker",
-  "PackageLocation",
-  "PreferredInterfaceType",
-  "PreferJavaTimeOverload",
-  "RedundantThrows",
-  "RemoveUnusedImports",
-  "ReturnsNullCollection",
-  "SelfAlwaysReturnsThis",
-  "StringFormatWithLiteral",
-  "StronglyTypeByteString",
-  "StronglyTypeTime",
-  "SunApi",
-  "SwitchDefault",
-  "TimeUnitMismatch",
-  "TransientMisuse",
-  "TruthContainsExactlyElementsInUsage",
-  "UnnecessarilyVisible",
-  "UnnecessaryAnonymousClass",
-  "UnnecessaryOptionalGet",
-  "UnnecessarilyUsedValue",
-  "UnsafeLocaleUsage",
-  "UnusedTypeParameter",
-  "UsingJsr305CheckReturnValue",
-  "YodaCondition",
+  "SuppressWarningsWithoutExplanation",
+  "UngroupedOverloads",
 )
 fun disabledRules() = listOf(
   "ImmutableListRules\\\$ImmutableListBuilder",
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 9fc13ff662..f037e24c87 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,4 +1,4 @@
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
diff --git a/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaCache.java b/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaCache.java
index e3215103d6..13efae59ed 100644
--- a/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaCache.java
+++ b/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaCache.java
@@ -57,10 +57,10 @@ class CaffeinatedGuavaCache<K, V> implements Cache<K, V>, Serializable {
     this.cache = requireNonNull(cache);
   }
 
-  @Override @Nullable
-  public V getIfPresent(Object key) {
+  @Override
+  public @Nullable V getIfPresent(Object key) {
     @SuppressWarnings("unchecked")
-    K castedKey = (K) key;
+    var castedKey = (K) key;
     return cache.getIfPresent(castedKey);
   }
 
@@ -114,7 +114,7 @@ public void putAll(Map<? extends K, ? extends V> m) {
   @Override
   public void invalidate(Object key) {
     @SuppressWarnings("unchecked")
-    K castedKey = (K) key;
+    var castedKey = (K) key;
     cache.invalidate(castedKey);
   }
 
@@ -240,7 +240,7 @@ static final class CacheLoaderException extends RuntimeException {
     private static final long serialVersionUID = 1L;
 
     CacheLoaderException(Throwable cause) {
-      super(null, cause, /* enableSuppression */ false, /* writableStackTrace */ false);
+      super(null, cause, /* enableSuppression= */ false, /* writableStackTrace= */ false);
     }
   }
 }
diff --git a/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaLoadingCache.java b/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaLoadingCache.java
index 25a3441f46..c428c3d804 100644
--- a/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaLoadingCache.java
+++ b/guava/src/main/java/com/github/benmanes/caffeine/guava/CaffeinatedGuavaLoadingCache.java
@@ -188,7 +188,7 @@ static final class InternalBulkLoader<K, V> extends InternalSingleLoader<K, V> {
         if (loaded == null) {
           throw new InvalidCacheLoadException("null map");
         }
-        Map<K, V> result = new HashMap<>(loaded.size(), /* load factor */ 1.0f);
+        var result = new HashMap<K, V>(loaded.size(), /* loadFactor= */ 1.0f);
         loaded.forEach((key, value) -> {
           if ((key == null) || (value == null)) {
             nullBulkLoad.set(true);
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheFactory.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheFactory.java
index 5e484c2430..543d2aa336 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheFactory.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheFactory.java
@@ -43,6 +43,7 @@
 import com.github.benmanes.caffeine.jcache.event.JCacheEvictionListener;
 import com.github.benmanes.caffeine.jcache.integration.JCacheLoaderAdapter;
 import com.github.benmanes.caffeine.jcache.management.JCacheStatisticsMXBean;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -73,7 +74,7 @@ public static boolean isDefinedExternally(CacheManager cacheManager, String cach
    * @return a new cache instance or null if the named cache is not defined in the settings file
    */
   @SuppressWarnings("resource")
-  public static @Nullable <K, V> CacheProxy<K, V> tryToCreateFromExternalSettings(
+  public static <K, V> @Nullable CacheProxy<K, V> tryToCreateFromExternalSettings(
       CacheManager cacheManager, String cacheName) {
     return TypesafeConfigurator.<K, V>from(rootConfig(cacheManager), cacheName)
         .map(configuration -> createCache(cacheManager, cacheName, configuration))
@@ -110,7 +111,7 @@ private static <K, V> CaffeineConfiguration<K, V> resolveConfigurationFor(
 
     CaffeineConfiguration<K, V> template = TypesafeConfigurator.defaults(rootConfig(cacheManager));
     if (configuration instanceof CompleteConfiguration<?, ?>) {
-      CompleteConfiguration<K, V> complete = (CompleteConfiguration<K, V>) configuration;
+      var complete = (CompleteConfiguration<K, V>) configuration;
       template.setReadThrough(complete.isReadThrough());
       template.setWriteThrough(complete.isWriteThrough());
       template.setManagementEnabled(complete.isManagementEnabled());
@@ -162,11 +163,11 @@ private static final class Builder<K, V> {
 
     /** Creates a configured cache. */
     public CacheProxy<K, V> build() {
-      boolean evicts = false;
+      @Var boolean evicts = false;
       evicts |= configureMaximumSize();
       evicts |= configureMaximumWeight();
 
-      boolean expires = false;
+      @Var boolean expires = false;
       expires |= configureExpireAfterWrite();
       expires |= configureExpireAfterAccess();
       expires |= configureExpireVariably();
@@ -178,7 +179,7 @@ public CacheProxy<K, V> build() {
         caffeine.recordStats();
       }
 
-      JCacheEvictionListener<K, V> evictionListener = null;
+      @Var JCacheEvictionListener<K, V> evictionListener = null;
       if (evicts || expires) {
         evictionListener = new JCacheEvictionListener<>(dispatcher, statistics);
         caffeine.evictionListener(evictionListener);
@@ -219,9 +220,9 @@ private CacheProxy<K, V> newLoadingCacheProxy() {
       }
 
       CacheLoader<K, V> cacheLoader = factory.create();
-      JCacheLoaderAdapter<K, V> adapter = new JCacheLoaderAdapter<>(
+      var adapter = new JCacheLoaderAdapter<>(
           cacheLoader, dispatcher, expiryPolicy, ticker, statistics);
-      CacheProxy<K, V> cache = new LoadingCacheProxy<>(cacheName, executor, cacheManager, config,
+      var cache = new LoadingCacheProxy<>(cacheName, executor, cacheManager, config,
           caffeine.build(adapter), dispatcher, cacheLoader, expiryPolicy, ticker, statistics);
       adapter.setCache(cache);
       return cache;
@@ -327,12 +328,12 @@ public ExpirableToExpiry(Ticker ticker) {
       return toNanos(expirable);
     }
     private long toNanos(Expirable<V> expirable) {
-      if (expirable.getExpireTimeMS() == 0L) {
+      if (expirable.getExpireTimeMillis() == 0L) {
         return -1L;
       } else if (expirable.isEternal()) {
         return Long.MAX_VALUE;
       }
-      return TimeUnit.MILLISECONDS.toNanos(expirable.getExpireTimeMS()) - ticker.read();
+      return TimeUnit.MILLISECONDS.toNanos(expirable.getExpireTimeMillis()) - ticker.read();
     }
   }
 }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheManagerImpl.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheManagerImpl.java
index cadc9b5b70..828540ba4e 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheManagerImpl.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheManagerImpl.java
@@ -111,7 +111,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(
       enableStatistics(cache.getName(), config.isStatisticsEnabled());
 
       @SuppressWarnings("unchecked")
-      Cache<K, V> castedCache = (Cache<K, V>) cache;
+      var castedCache = (Cache<K, V>) cache;
       return castedCache;
     } finally {
       Thread.currentThread().setContextClassLoader(old);
@@ -119,7 +119,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(
   }
 
   @Override
-  public @Nullable <K, V> Cache<K, V> getCache(
+  public <K, V> @Nullable Cache<K, V> getCache(
       String cacheName, Class<K> keyType, Class<V> valueType) {
     ClassLoader old = Thread.currentThread().getContextClassLoader();
     try {
@@ -172,7 +172,7 @@ public <K, V> CacheProxy<K, V> getCache(String cacheName) {
       });
 
       @SuppressWarnings("unchecked")
-      CacheProxy<K, V> castedCache = (CacheProxy<K, V>) cache;
+      var castedCache = (CacheProxy<K, V>) cache;
       return castedCache;
     } finally {
       Thread.currentThread().setContextClassLoader(old);
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheProxy.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheProxy.java
index 0adc36ccf1..a73f918fc0 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheProxy.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheProxy.java
@@ -74,6 +74,7 @@
 import com.github.benmanes.caffeine.jcache.management.JmxRegistration.MBeanType;
 import com.github.benmanes.caffeine.jcache.processor.EntryProcessorEntry;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * An implementation of JSR-107 {@link Cache} backed by a Caffeine cache.
@@ -94,14 +95,14 @@ public class CacheProxy<K, V> implements Cache<K, V> {
   private final CaffeineConfiguration<K, V> configuration;
   private final CacheManager cacheManager;
   private final CacheWriter<K, V> writer;
-  private final JCacheMXBean cacheMXBean;
+  private final JCacheMXBean cacheMxBean;
   private final ExpiryPolicy expiry;
   private final Copier copier;
   private final String name;
 
   private volatile boolean closed;
 
-  @SuppressWarnings({"PMD.ExcessiveParameterList", "this-escape"})
+  @SuppressWarnings({"PMD.ExcessiveParameterList", "this-escape", "TooManyParameters"})
   public CacheProxy(String name, Executor executor, CacheManager cacheManager,
       CaffeineConfiguration<K, V> configuration,
       com.github.benmanes.caffeine.cache.Cache<K, Expirable<V>> cache,
@@ -122,7 +123,7 @@ public CacheProxy(String name, Executor executor, CacheManager cacheManager,
     copier = configuration.isStoreByValue()
         ? configuration.getCopierFactory().create()
         : Copier.identity();
-    cacheMXBean = new JCacheMXBean(this);
+    cacheMxBean = new JCacheMXBean(this);
     inFlight = ConcurrentHashMap.newKeySet();
   }
 
@@ -157,7 +158,8 @@ public boolean containsKey(K key) {
       return null;
     }
 
-    long start, millis;
+    long start;
+    long millis;
     boolean statsEnabled = statistics.isEnabled();
     if (!expirable.isEternal()) {
       start = ticker.read();
@@ -198,7 +200,7 @@ public Map<K, V> getAll(Set<? extends K> keys) {
     boolean statsEnabled = statistics.isEnabled();
     long now = statsEnabled ? ticker.read() : 0L;
 
-    Map<K, Expirable<V>> result = getAndFilterExpiredEntries(keys, true);
+    Map<K, Expirable<V>> result = getAndFilterExpiredEntries(keys, /* updateAccessTime= */ true);
 
     if (statsEnabled) {
       statistics.recordGetTime(ticker.read() - now);
@@ -283,7 +285,7 @@ public void loadAll(Set<? extends K> keys, boolean replaceExistingValues,
   private void loadAllAndReplaceExisting(Set<? extends K> keys) {
     Map<K, V> loaded = cacheLoader.orElseThrow().loadAll(keys);
     for (var entry : loaded.entrySet()) {
-      putNoCopyOrAwait(entry.getKey(), entry.getValue(), /* publishToWriter */ false);
+      putNoCopyOrAwait(entry.getKey(), entry.getValue(), /* publishToWriter= */ false);
     }
   }
 
@@ -295,7 +297,7 @@ private void loadAllAndKeepExisting(Set<? extends K> keys) {
     Map<K, V> result = cacheLoader.orElseThrow().loadAll(keysToLoad);
     for (var entry : result.entrySet()) {
       if ((entry.getKey() != null) && (entry.getValue() != null)) {
-        putIfAbsentNoAwait(entry.getKey(), entry.getValue(), /* publishToWriter */ false);
+        putIfAbsentNoAwait(entry.getKey(), entry.getValue(), /* publishToWriter= */ false);
       }
     }
   }
@@ -306,7 +308,7 @@ public void put(K key, V value) {
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
 
-    var result = putNoCopyOrAwait(key, value, /* publishToWriter */ true);
+    var result = putNoCopyOrAwait(key, value, /* publishToWriter= */ true);
     dispatcher.awaitSynchronous();
 
     if (statsEnabled) {
@@ -323,7 +325,7 @@ public void put(K key, V value) {
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
 
-    var result = putNoCopyOrAwait(key, value, true);
+    var result = putNoCopyOrAwait(key, value, /* publishToWriter= */ true);
     dispatcher.awaitSynchronous();
 
     if (statsEnabled) {
@@ -356,7 +358,7 @@ protected PutResult<V> putNoCopyOrAwait(K key, V value, boolean publishToWriter)
     requireNonNull(value);
 
     var result = new PutResult<V>();
-    cache.asMap().compute(copyOf(key), (k, expirable) -> {
+    cache.asMap().compute(copyOf(key), (K k, @Var Expirable<V> expirable) -> {
       V newValue = copyOf(value);
       if (publishToWriter) {
         publishToCacheWriter(writer::write, () -> new EntryProxy<>(key, value));
@@ -367,11 +369,11 @@ protected PutResult<V> putNoCopyOrAwait(K key, V value, boolean publishToWriter)
         statistics.recordEvictions(1L);
         expirable = null;
       }
-      long expireTimeMS = getWriteExpireTimeMS((expirable == null));
-      if ((expirable != null) && (expireTimeMS == Long.MIN_VALUE)) {
-        expireTimeMS = expirable.getExpireTimeMS();
+      @Var long expireTimeMillis = getWriteexpireTimeMillis((expirable == null));
+      if ((expirable != null) && (expireTimeMillis == Long.MIN_VALUE)) {
+        expireTimeMillis = expirable.getExpireTimeMillis();
       }
-      if (expireTimeMS == 0) {
+      if (expireTimeMillis == 0) {
         // The TCK asserts that expired entry is not counted in the puts stats, despite the javadoc
         // saying otherwise. See CacheMBStatisticsBeanTest.testExpiryOnCreation()
         result.written = false;
@@ -389,7 +391,7 @@ protected PutResult<V> putNoCopyOrAwait(K key, V value, boolean publishToWriter)
         dispatcher.publishUpdated(this, key, expirable.get(), newValue);
       }
       result.written = true;
-      return new Expirable<>(newValue, expireTimeMS);
+      return new Expirable<>(newValue, expireTimeMillis);
     });
     return result;
   }
@@ -402,8 +404,8 @@ public void putAll(Map<? extends K, ? extends V> map) {
       requireNonNull(entry.getValue());
     }
 
-    CacheWriterException error = null;
-    Set<? extends K> failedKeys = Set.of();
+    @Var CacheWriterException error = null;
+    @Var Set<? extends K> failedKeys = Set.of();
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
     if (configuration.isWriteThrough() && !map.isEmpty()) {
@@ -422,11 +424,11 @@ public void putAll(Map<? extends K, ? extends V> map) {
       }
     }
 
-    int puts = 0;
+    @Var int puts = 0;
     for (var entry : map.entrySet()) {
       if (!failedKeys.contains(entry.getKey())) {
         var result = putNoCopyOrAwait(entry.getKey(),
-            entry.getValue(), /* publishToWriter */ false);
+            entry.getValue(), /* publishToWriter= */ false);
         if (result.written) {
           puts++;
         }
@@ -451,7 +453,7 @@ public boolean putIfAbsent(K key, V value) {
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
 
-    boolean added = putIfAbsentNoAwait(key, value, /* publishToWriter */ true);
+    boolean added = putIfAbsentNoAwait(key, value, /* publishToWriter= */ true);
     dispatcher.awaitSynchronous();
 
     if (statsEnabled) {
@@ -478,7 +480,7 @@ public boolean putIfAbsent(K key, V value) {
   @CanIgnoreReturnValue
   private boolean putIfAbsentNoAwait(K key, V value, boolean publishToWriter) {
     boolean[] absent = { false };
-    cache.asMap().compute(copyOf(key), (k, expirable) -> {
+    cache.asMap().compute(copyOf(key), (K k, @Var Expirable<V> expirable) -> {
       if ((expirable != null) && !expirable.isEternal()
           && expirable.hasExpired(currentTimeMillis())) {
         dispatcher.publishExpired(this, key, expirable.get());
@@ -494,15 +496,15 @@ private boolean putIfAbsentNoAwait(K key, V value, boolean publishToWriter) {
 
       absent[0] = true;
       V copy = copyOf(value);
-      long expireTimeMS = getWriteExpireTimeMS(/* created */ true);
-      if (expireTimeMS == 0) {
+      long expireTimeMillis = getWriteexpireTimeMillis(/* created= */ true);
+      if (expireTimeMillis == 0) {
         // The TCK asserts that a create is not published in
         // CacheExpiryTest.expire_whenCreated_CreatedExpiryPolicy()
         dispatcher.publishExpired(this, key, copy);
         return null;
       } else {
         dispatcher.publishCreated(this, key, copy);
-        return new Expirable<>(copy, expireTimeMS);
+        return new Expirable<>(copy, expireTimeMillis);
       }
     });
     return absent[0];
@@ -539,7 +541,7 @@ public boolean remove(K key) {
    */
   private V removeNoCopyOrAwait(K key) {
     @SuppressWarnings("unchecked")
-    V[] removed = (V[]) new Object[1];
+    var removed = (V[]) new Object[1];
     cache.asMap().computeIfPresent(key, (k, expirable) -> {
       if (!expirable.isEternal() && expirable.hasExpired(currentTimeMillis())) {
         dispatcher.publishExpired(this, key, expirable.get());
@@ -649,11 +651,11 @@ public boolean replace(K key, V oldValue, V newValue) {
       if (oldValue.equals(expirable.get())) {
         publishToCacheWriter(writer::write, () -> new EntryProxy<>(key, expirable.get()));
         dispatcher.publishUpdated(this, key, expirable.get(), copyOf(newValue));
-        long expireTimeMS = getWriteExpireTimeMS(/* created */ false);
-        if (expireTimeMS == Long.MIN_VALUE) {
-          expireTimeMS = expirable.getExpireTimeMS();
+        @Var long expireTimeMillis = getWriteexpireTimeMillis(/* created= */ false);
+        if (expireTimeMillis == Long.MIN_VALUE) {
+          expireTimeMillis = expirable.getExpireTimeMillis();
         }
-        result = new Expirable<>(newValue, expireTimeMS);
+        result = new Expirable<>(newValue, expireTimeMillis);
         replaced[0] = true;
       } else {
         result = expirable;
@@ -734,7 +736,7 @@ private V replaceNoCopyOrAwait(K key, V value) {
     requireNonNull(value);
     V copy = copyOf(value);
     @SuppressWarnings("unchecked")
-    V[] replaced = (V[]) new Object[1];
+    var replaced = (V[]) new Object[1];
     cache.asMap().computeIfPresent(key, (k, expirable) -> {
       if (!expirable.isEternal() && expirable.hasExpired(currentTimeMillis())) {
         dispatcher.publishExpired(this, key, expirable.get());
@@ -743,13 +745,13 @@ private V replaceNoCopyOrAwait(K key, V value) {
       }
 
       publishToCacheWriter(writer::write, () -> new EntryProxy<>(key, value));
-      long expireTimeMS = getWriteExpireTimeMS(/* created */ false);
-      if (expireTimeMS == Long.MIN_VALUE) {
-        expireTimeMS = expirable.getExpireTimeMS();
+      @Var long expireTimeMillis = getWriteexpireTimeMillis(/* created= */ false);
+      if (expireTimeMillis == Long.MIN_VALUE) {
+        expireTimeMillis = expirable.getExpireTimeMillis();
       }
       dispatcher.publishUpdated(this, key, expirable.get(), copy);
       replaced[0] = expirable.get();
-      return new Expirable<>(copy, expireTimeMS);
+      return new Expirable<>(copy, expireTimeMillis);
     });
     return replaced[0];
   }
@@ -759,8 +761,8 @@ public void removeAll(Set<? extends K> keys) {
     requireNotClosed();
     keys.forEach(Objects::requireNonNull);
 
-    CacheWriterException error = null;
-    Set<? extends K> failedKeys = Set.of();
+    @Var CacheWriterException error = null;
+    @Var Set<? extends K> failedKeys = Set.of();
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
     if (configuration.isWriteThrough() && !keys.isEmpty()) {
@@ -776,7 +778,7 @@ public void removeAll(Set<? extends K> keys) {
       }
     }
 
-    int removed = 0;
+    @Var int removed = 0;
     for (var key : keys) {
       if (!failedKeys.contains(key) && (removeNoCopyOrAwait(key) != null)) {
         removed++;
@@ -816,7 +818,7 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
   }
 
   @Override
-  public @Nullable <T> T invoke(K key,
+  public <T> @Nullable T invoke(K key,
       EntryProcessor<K, V, T> entryProcessor, Object... arguments) {
     requireNonNull(entryProcessor);
     requireNonNull(arguments);
@@ -825,7 +827,7 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
     Object[] result = new Object[1];
     BiFunction<K, Expirable<V>, Expirable<V>> remappingFunction = (k, expirable) -> {
       V value;
-      long millis = 0L;
+      @Var long millis = 0L;
       if ((expirable == null)
           || (!expirable.isEternal() && expirable.hasExpired(millis = currentTimeMillis()))) {
         statistics.recordMisses(1L);
@@ -834,7 +836,7 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
         value = copyValue(expirable);
         statistics.recordHits(1L);
       }
-      EntryProcessorEntry<K, V> entry = new EntryProcessorEntry<>(key, value,
+      var entry = new EntryProcessorEntry<>(key, value,
           configuration.isReadThrough() ? cacheLoader : Optional.empty());
       try {
         result[0] = entryProcessor.process(entry, arguments);
@@ -854,14 +856,14 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
     }
 
     @SuppressWarnings("unchecked")
-    T castedResult = (T) result[0];
+    var castedResult = (T) result[0];
     return castedResult;
   }
 
   /** Returns the updated expirable value after performing the post-processing actions. */
   @SuppressWarnings({"fallthrough", "NullAway", "PMD.MissingBreakInSwitch"})
   private @Nullable Expirable<V> postProcess(@Nullable Expirable<V> expirable,
-      EntryProcessorEntry<K, V> entry, long currentTimeMS) {
+      EntryProcessorEntry<K, V> entry, @Var long currentTimeMillis) {
     switch (entry.getAction()) {
       case NONE:
         if (expirable == null) {
@@ -869,10 +871,10 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
         } else if (expirable.isEternal()) {
           return expirable;
         }
-        if (currentTimeMS == 0) {
-          currentTimeMS = currentTimeMillis();
+        if (currentTimeMillis == 0) {
+          currentTimeMillis = currentTimeMillis();
         }
-        if (expirable.hasExpired(currentTimeMS)) {
+        if (expirable.hasExpired(currentTimeMillis)) {
           dispatcher.publishExpired(this, entry.getKey(), expirable.get());
           statistics.recordEvictions(1);
           return null;
@@ -888,17 +890,17 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
       case LOADED:
         statistics.recordPuts(1L);
         dispatcher.publishCreated(this, entry.getKey(), entry.getValue());
-        return new Expirable<>(entry.getValue(), getWriteExpireTimeMS(/* created */ true));
+        return new Expirable<>(entry.getValue(), getWriteexpireTimeMillis(/* created= */ true));
       case UPDATED: {
         statistics.recordPuts(1L);
         publishToCacheWriter(writer::write, () -> entry);
         requireNonNull(expirable, "Expected a previous value but was null");
         dispatcher.publishUpdated(this, entry.getKey(), expirable.get(), entry.getValue());
-        long expireTimeMS = getWriteExpireTimeMS(/* created */ false);
-        if (expireTimeMS == Long.MIN_VALUE) {
-          expireTimeMS = expirable.getExpireTimeMS();
+        @Var long expireTimeMillis = getWriteexpireTimeMillis(/* created= */ false);
+        if (expireTimeMillis == Long.MIN_VALUE) {
+          expireTimeMillis = expirable.getExpireTimeMillis();
         }
-        return new Expirable<>(entry.getValue(), expireTimeMS);
+        return new Expirable<>(entry.getValue(), expireTimeMillis);
       }
       case DELETED:
         statistics.recordRemovals(1L);
@@ -914,7 +916,7 @@ public <C extends Configuration<K, V>> C getConfiguration(Class<C> clazz) {
   @Override
   public <T> Map<K, EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
       EntryProcessor<K, V, T> entryProcessor, Object... arguments) {
-    Map<K, EntryProcessorResult<T>> results = new HashMap<>(keys.size(), 1.0f);
+    var results = new HashMap<K, EntryProcessorResult<T>>(keys.size(), 1.0f);
     for (K key : keys) {
       try {
         T result = invoke(key, entryProcessor, arguments);
@@ -955,7 +957,7 @@ public void close() {
         cacheManager.destroyCache(name);
         closed = true;
 
-        var thrown = shutdownExecutor();
+        @Var var thrown = shutdownExecutor();
         thrown = tryClose(expiry, thrown);
         thrown = tryClose(writer, thrown);
         thrown = tryClose(executor, thrown);
@@ -978,7 +980,7 @@ public void close() {
       es.shutdown();
     }
 
-    Throwable thrown = null;
+    @Var Throwable thrown = null;
     try {
       CompletableFuture
           .allOf(inFlight.toArray(CompletableFuture[]::new))
@@ -1056,9 +1058,9 @@ void enableManagement(boolean enabled) {
 
     synchronized (configuration) {
       if (enabled) {
-        JmxRegistration.registerMXBean(this, cacheMXBean, MBeanType.Configuration);
+        JmxRegistration.registerMxBean(this, cacheMxBean, MBeanType.CONFIGURATION);
       } else {
-        JmxRegistration.unregisterMXBean(this, MBeanType.Configuration);
+        JmxRegistration.unregisterMxBean(this, MBeanType.CONFIGURATION);
       }
       configuration.setManagementEnabled(enabled);
     }
@@ -1070,9 +1072,9 @@ void enableStatistics(boolean enabled) {
 
     synchronized (configuration) {
       if (enabled) {
-        JmxRegistration.registerMXBean(this, statistics, MBeanType.Statistics);
+        JmxRegistration.registerMxBean(this, statistics, MBeanType.STATISTICS);
       } else {
-        JmxRegistration.unregisterMXBean(this, MBeanType.Statistics);
+        JmxRegistration.unregisterMxBean(this, MBeanType.STATISTICS);
       }
       statistics.enable(enabled);
       configuration.setStatisticsEnabled(enabled);
@@ -1160,23 +1162,24 @@ protected static long nanosToMillis(long nanos) {
    *
    * @param key the entry's key
    * @param expirable the entry that was operated on
-   * @param currentTimeMS the current time, or 0 if not read yet
+   * @param currentTimeMillis the current time, or 0 if not read yet
    */
-  protected final void setAccessExpireTime(K key, Expirable<?> expirable, long currentTimeMS) {
+  protected final void setAccessExpireTime(K key,
+      Expirable<?> expirable, @Var long currentTimeMillis) {
     try {
       Duration duration = expiry.getExpiryForAccess();
       if (duration == null) {
         return;
       } else if (duration.isZero()) {
-        expirable.setExpireTimeMS(0L);
+        expirable.setExpireTimeMillis(0L);
       } else if (duration.isEternal()) {
-        expirable.setExpireTimeMS(Long.MAX_VALUE);
+        expirable.setExpireTimeMillis(Long.MAX_VALUE);
       } else {
-        if (currentTimeMS == 0L) {
-          currentTimeMS = currentTimeMillis();
+        if (currentTimeMillis == 0L) {
+          currentTimeMillis = currentTimeMillis();
         }
-        long expireTimeMS = duration.getAdjustedTime(currentTimeMS);
-        expirable.setExpireTimeMS(expireTimeMS);
+        long expireTimeMillis = duration.getAdjustedTime(currentTimeMillis);
+        expirable.setExpireTimeMillis(expireTimeMillis);
       }
       cache.policy().expireVariably().ifPresent(policy -> {
         policy.setExpiresAfter(key, duration.getDurationAmount(), duration.getTimeUnit());
@@ -1193,7 +1196,7 @@ protected final void setAccessExpireTime(K key, Expirable<?> expirable, long cur
    * @return the time when the entry will expire, zero if it should expire immediately,
    *         Long.MIN_VALUE if it should not be changed, or Long.MAX_VALUE if eternal
    */
-  protected final long getWriteExpireTimeMS(boolean created) {
+  protected final long getWriteexpireTimeMillis(boolean created) {
     try {
       Duration duration = created ? expiry.getExpiryForCreation() : expiry.getExpiryForUpdate();
       if (duration == null) {
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/EntryProxy.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/EntryProxy.java
index bb5001933c..eb30fa1f2a 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/EntryProxy.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/EntryProxy.java
@@ -38,7 +38,7 @@ public <T> T unwrap(Class<T> clazz) {
       throw new IllegalArgumentException("Class " + clazz + " is unknown to this implementation");
     }
     @SuppressWarnings("unchecked")
-    T castedEntry = (T) this;
+    var castedEntry = (T) this;
     return castedEntry;
   }
 }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/Expirable.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/Expirable.java
index 477228cde8..e1c56e2fb0 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/Expirable.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/Expirable.java
@@ -26,11 +26,11 @@
 public final class Expirable<V> {
   private final V value;
 
-  private volatile long expireTimeMS;
+  private volatile long expireTimeMillis;
 
-  public Expirable(V value, long expireTimeMS) {
+  public Expirable(V value, long expireTimeMillis) {
     this.value = requireNonNull(value);
-    this.expireTimeMS = expireTimeMS;
+    this.expireTimeMillis = expireTimeMillis;
   }
 
   /** Returns the value. */
@@ -39,28 +39,28 @@ public V get() {
   }
 
   /** Returns the time, in milliseconds, when the value will expire. */
-  public long getExpireTimeMS() {
-    return expireTimeMS;
+  public long getExpireTimeMillis() {
+    return expireTimeMillis;
   }
 
   /** Specifies the time, in milliseconds, when the value will expire. */
-  public void setExpireTimeMS(long expireTimeMS) {
-    this.expireTimeMS = expireTimeMS;
+  public void setExpireTimeMillis(long expireTimeMillis) {
+    this.expireTimeMillis = expireTimeMillis;
   }
 
   /** Returns if the value has expired and is eligible for eviction. */
-  public boolean hasExpired(long currentTimeMS) {
-    return (currentTimeMS - expireTimeMS) >= 0;
+  public boolean hasExpired(long currentTimeMillis) {
+    return (currentTimeMillis - expireTimeMillis) >= 0;
   }
 
   /** Returns if the value will never expire. */
   public boolean isEternal() {
-    return (expireTimeMS == Long.MAX_VALUE);
+    return (expireTimeMillis == Long.MAX_VALUE);
   }
 
   @Override
   public String toString() {
-    return String.format(US, "%s{value=%s, expireTimeMS=%,d}",
-        getClass().getSimpleName(), value, expireTimeMS);
+    return String.format(US, "%s{value=%s, expireTimeMillis=%,d}",
+        getClass().getSimpleName(), value, expireTimeMillis);
   }
 }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/LoadingCacheProxy.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/LoadingCacheProxy.java
index 962db40052..9c3efe979f 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/LoadingCacheProxy.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/LoadingCacheProxy.java
@@ -39,6 +39,7 @@
 import com.github.benmanes.caffeine.jcache.configuration.CaffeineConfiguration;
 import com.github.benmanes.caffeine.jcache.event.EventDispatcher;
 import com.github.benmanes.caffeine.jcache.management.JCacheStatisticsMXBean;
+import com.google.errorprone.annotations.Var;
 
 /**
  * An implementation of JSR-107 {@link Cache} backed by a Caffeine loading cache.
@@ -49,7 +50,7 @@
 public final class LoadingCacheProxy<K, V> extends CacheProxy<K, V> {
   private final LoadingCache<K, Expirable<V>> cache;
 
-  @SuppressWarnings("PMD.ExcessiveParameterList")
+  @SuppressWarnings({"PMD.ExcessiveParameterList", "TooManyParameters"})
   public LoadingCacheProxy(String name, Executor executor, CacheManager cacheManager,
       CaffeineConfiguration<K, V> configuration, LoadingCache<K, Expirable<V>> cache,
       EventDispatcher<K, V> dispatcher, CacheLoader<K, V> cacheLoader,
@@ -80,8 +81,8 @@ public LoadingCacheProxy(String name, Executor executor, CacheManager cacheManag
     boolean statsEnabled = statistics.isEnabled();
     long start = statsEnabled ? ticker.read() : 0L;
 
-    long millis = 0L;
-    Expirable<V> expirable = cache.getIfPresent(key);
+    @Var long millis = 0L;
+    @Var Expirable<V> expirable = cache.getIfPresent(key);
     if ((expirable != null) && !expirable.isEternal()) {
       millis = nanosToMillis((start == 0L) ? ticker.read() : start);
       if (expirable.hasExpired(millis)) {
@@ -105,7 +106,7 @@ public LoadingCacheProxy(String name, Executor executor, CacheManager cacheManag
       statistics.recordHits(1L);
     }
 
-    V value = null;
+    @Var V value = null;
     if (expirable != null) {
       setAccessExpireTime(key, expirable, millis);
       value = copyValue(expirable);
@@ -118,7 +119,7 @@ public LoadingCacheProxy(String name, Executor executor, CacheManager cacheManag
 
   @Override
   public Map<K, V> getAll(Set<? extends K> keys) {
-    return getAll(keys, true);
+    return getAll(keys, /* updateAccessTime= */ true);
   }
 
   /** Returns the entries, loading if necessary, and optionally updates their access expiry time. */
@@ -167,10 +168,10 @@ public void loadAll(Set<? extends K> keys, boolean replaceExistingValues,
           @SuppressWarnings("NullAway")
           Map<K, V> loaded = cacheLoader.orElseThrow().loadAll(keys);
           for (var entry : loaded.entrySet()) {
-            putNoCopyOrAwait(entry.getKey(), entry.getValue(), /* publishToWriter */ false);
+            putNoCopyOrAwait(entry.getKey(), entry.getValue(), /* publishToWriter= */ false);
           }
         } else {
-          getAll(keys, /* updateAccessTime */ false);
+          getAll(keys, /* updateAccessTime= */ false);
         }
         listener.onCompletion();
       } catch (RuntimeException e) {
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/CaffeineConfiguration.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/CaffeineConfiguration.java
index 91d890861c..17faecc1bd 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/CaffeineConfiguration.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/CaffeineConfiguration.java
@@ -90,13 +90,13 @@ public CaffeineConfiguration() {
 
   /** Returns a modifiable copy of the configuration. */
   public CaffeineConfiguration(CompleteConfiguration<K, V> configuration) {
-    this(configuration, /* readOnly */ false);
+    this(configuration, /* readOnly= */ false);
   }
 
   private CaffeineConfiguration(CompleteConfiguration<K, V> configuration, boolean readOnly) {
     delegate = new MutableConfiguration<>(configuration);
     if (configuration instanceof CaffeineConfiguration<?, ?>) {
-      CaffeineConfiguration<K, V> config = (CaffeineConfiguration<K, V>) configuration;
+      var config = (CaffeineConfiguration<K, V>) configuration;
       refreshAfterWriteNanos = config.refreshAfterWriteNanos;
       expireAfterAccessNanos = config.expireAfterAccessNanos;
       expireAfterWriteNanos = config.expireAfterWriteNanos;
@@ -120,7 +120,7 @@ private CaffeineConfiguration(CompleteConfiguration<K, V> configuration, boolean
 
   /** Returns an unmodifiable copy of this configuration. */
   public CaffeineConfiguration<K, V> immutableCopy() {
-    return new CaffeineConfiguration<>(this, /* immutable */ true);
+    return new CaffeineConfiguration<>(this, /* readOnly= */ true);
   }
 
   private void checkIfReadOnly() {
@@ -198,7 +198,7 @@ public CaffeineConfiguration<K, V> setCacheLoaderFactory(
     var factory = delegate.getCacheWriterFactory();
     if (factory != null) {
       @SuppressWarnings("unchecked")
-      CacheWriter<K , V> writer = (CacheWriter<K, V>) factory.create();
+      var writer = (CacheWriter<K, V>) factory.create();
       return writer;
     }
     return null;
@@ -612,7 +612,7 @@ public boolean equals(Object o) {
     } else if (!(o instanceof CaffeineConfiguration<?, ?>)) {
       return false;
     }
-    CaffeineConfiguration<?, ?> config = (CaffeineConfiguration<?, ?>) o;
+    var config = (CaffeineConfiguration<?, ?>) o;
     return Objects.equals(refreshAfterWriteNanos, config.refreshAfterWriteNanos)
         && Objects.equals(expireAfterAccessNanos, config.expireAfterAccessNanos)
         && Objects.equals(expireAfterWriteNanos, config.expireAfterWriteNanos)
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/TypesafeConfigurator.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/TypesafeConfigurator.java
index d71f25f6d1..a8e9963cb9 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/TypesafeConfigurator.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/configuration/TypesafeConfigurator.java
@@ -44,6 +44,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import com.github.benmanes.caffeine.jcache.expiry.JCacheExpiryPolicy;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigException;
 import com.typesafe.config.ConfigFactory;
@@ -103,15 +104,14 @@ public static <K, V> CaffeineConfiguration<K, V> defaults(Config config) {
    * @return the configuration for the cache
    */
   public static <K, V> Optional<CaffeineConfiguration<K, V>> from(Config config, String cacheName) {
-    CaffeineConfiguration<K, V> configuration = null;
     try {
-      if (config.hasPath("caffeine.jcache." + cacheName)) {
-        configuration = new Configurator<K, V>(config, cacheName).configure();
-      }
+      return config.hasPath("caffeine.jcache." + cacheName)
+          ? Optional.of(new Configurator<K, V>(config, cacheName).configure())
+          : Optional.empty();
     } catch (ConfigException.BadPath e) {
       logger.log(Level.WARNING, "Failed to load cache configuration", e);
+      return Optional.empty();
     }
-    return Optional.ofNullable(configuration);
   }
 
   /**
@@ -239,9 +239,9 @@ CaffeineConfiguration<K, V> configure() {
     private void addKeyValueTypes() {
       try {
         @SuppressWarnings("unchecked")
-        Class<K> keyType = (Class<K>) Class.forName(merged.getString("key-type"));
+        var keyType = (Class<K>) Class.forName(merged.getString("key-type"));
         @SuppressWarnings("unchecked")
-        Class<V> valueType = (Class<V>) Class.forName(merged.getString("value-type"));
+        var valueType = (Class<V>) Class.forName(merged.getString("value-type"));
         configuration.setTypes(keyType, valueType);
       } catch (ClassNotFoundException e) {
         throw new IllegalStateException(e);
@@ -278,7 +278,7 @@ private void addListeners() {
 
         Factory<? extends CacheEntryListener<? super K, ? super V>> listenerFactory =
             factoryCreator.factoryOf(listener.getString("class"));
-        Factory<? extends CacheEntryEventFilter<? super K, ? super V>> filterFactory = null;
+        @Var Factory<? extends CacheEntryEventFilter<? super K, ? super V>> filterFactory = null;
         if (listener.hasPath("filter")) {
           filterFactory = factoryCreator.factoryOf(listener.getString("filter"));
         }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/AbstractCopier.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/AbstractCopier.java
index c35d0dd799..2216c9fff0 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/AbstractCopier.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/AbstractCopier.java
@@ -45,7 +45,7 @@
  *
  * @author ben.manes@gmail.com (Ben Manes)
  */
-@SuppressWarnings({"JavaUtilDate", "JdkObsolete"})
+@SuppressWarnings({"ImmutableMemberCollection", "JavaUtilDate", "JdkObsolete"})
 public abstract class AbstractCopier<A> implements Copier {
   private static final Map<Class<?>, Function<Object, Object>> JAVA_DEEP_COPY = Map.of(Date.class,
       o -> ((Date) o).clone(), GregorianCalendar.class, o -> ((GregorianCalendar) o).clone());
@@ -92,7 +92,7 @@ public <T> T copy(T object, ClassLoader classLoader) {
     var deeplyCopyStrategy = deepCopyStrategies.get(object.getClass());
     if (deeplyCopyStrategy != null) {
       @SuppressWarnings("unchecked")
-      T copy = (T) deeplyCopyStrategy.apply(object);
+      var copy = (T) deeplyCopyStrategy.apply(object);
       return copy;
     }
 
@@ -133,7 +133,7 @@ private boolean isArrayOfImmutableTypes(Class<?> clazz) {
   private static <T> T arrayCopy(T object) {
     int length = Array.getLength(object);
     @SuppressWarnings("unchecked")
-    T copy = (T) Array.newInstance(object.getClass().getComponentType(), length);
+    var copy = (T) Array.newInstance(object.getClass().getComponentType(), length);
     System.arraycopy(object, 0, copy, 0, length);
     return copy;
   }
@@ -149,7 +149,7 @@ private static <T> T arrayCopy(T object) {
   protected <T> T roundtrip(T object, ClassLoader classLoader) {
     A data = serialize(object);
     @SuppressWarnings("unchecked")
-    T copy = (T) deserialize(data, classLoader);
+    var copy = (T) deserialize(data, classLoader);
     return copy;
   }
 
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/JavaSerializationCopier.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/JavaSerializationCopier.java
index 0698f8feee..0bee8a1f13 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/JavaSerializationCopier.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/copy/JavaSerializationCopier.java
@@ -100,7 +100,7 @@ protected ClassLoader getClassLoader() {
     protected Class<?> resolveClass(ObjectStreamClass desc)
         throws IOException, ClassNotFoundException {
       try {
-        return Class.forName(desc.getName(), /* initialize */ false, getClassLoader());
+        return Class.forName(desc.getName(), /* initialize= */ false, getClassLoader());
       } catch (ClassNotFoundException ex) {
         return super.resolveClass(desc);
       }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventDispatcher.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventDispatcher.java
index be6c30feee..eefc170686 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventDispatcher.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventDispatcher.java
@@ -37,6 +37,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * A dispatcher that publishes cache events to listeners for asynchronous execution.
  * <p>
@@ -93,11 +95,10 @@ public void register(CacheEntryListenerConfiguration<K, V> configuration) {
     var listener = new EventTypeAwareListener<K, V>(
         configuration.getCacheEntryListenerFactory().create());
 
-    CacheEntryEventFilter<K, V> filter = event -> true;
-    if (configuration.getCacheEntryEventFilterFactory() != null) {
-      filter = new EventTypeFilter<>(listener,
-          configuration.getCacheEntryEventFilterFactory().create());
-    }
+    var factory = configuration.getCacheEntryEventFilterFactory();
+    CacheEntryEventFilter<K, V> filter = (factory == null)
+        ? event -> true
+        : new EventTypeFilter<>(listener, factory.create());
 
     var registration = new Registration<>(configuration, filter, listener);
     dispatchQueues.putIfAbsent(registration, new ConcurrentHashMap<>());
@@ -122,8 +123,8 @@ public void deregister(CacheEntryListenerConfiguration<K, V> configuration) {
    * @param value the entry's value
    */
   public void publishCreated(Cache<K, V> cache, K key, V value) {
-    publish(cache, EventType.CREATED, key, /* hasOldValue */ false,
-        /* oldValue */ null, /* newValue */ value, /* quiet */ false);
+    publish(cache, EventType.CREATED, key, /* hasOldValue= */ false,
+        /* oldValue= */ null, /* newValue= */ value, /* quiet= */ false);
   }
 
   /**
@@ -135,8 +136,8 @@ public void publishCreated(Cache<K, V> cache, K key, V value) {
    * @param newValue the entry's new value
    */
   public void publishUpdated(Cache<K, V> cache, K key, V oldValue, V newValue) {
-    publish(cache, EventType.UPDATED, key, /* hasOldValue */ true,
-        oldValue, newValue, /* quiet */ false);
+    publish(cache, EventType.UPDATED, key, /* hasOldValue= */ true,
+        oldValue, newValue, /* quiet= */ false);
   }
 
   /**
@@ -147,8 +148,8 @@ public void publishUpdated(Cache<K, V> cache, K key, V oldValue, V newValue) {
    * @param value the entry's value
    */
   public void publishRemoved(Cache<K, V> cache, K key, V value) {
-    publish(cache, EventType.REMOVED, key, /* hasOldValue */ true,
-        /* oldValue */ value, /* newValue */ value, /* quiet */ false);
+    publish(cache, EventType.REMOVED, key, /* hasOldValue= */ true,
+        /* oldValue= */ value, /* newValue= */ value, /* quiet= */ false);
   }
 
   /**
@@ -160,8 +161,8 @@ public void publishRemoved(Cache<K, V> cache, K key, V value) {
    * @param value the entry's value
    */
   public void publishRemovedQuietly(Cache<K, V> cache, K key, V value) {
-    publish(cache, EventType.REMOVED, key, /* hasOldValue */ true,
-        /* oldValue */ value, /* newValue */ value, /* quiet */ true);
+    publish(cache, EventType.REMOVED, key, /* hasOldValue= */ true,
+        /* oldValue= */ value, /* newValue= */ value, /* quiet= */ true);
   }
 
   /**
@@ -172,8 +173,8 @@ public void publishRemovedQuietly(Cache<K, V> cache, K key, V value) {
    * @param value the entry's value
    */
   public void publishExpired(Cache<K, V> cache, K key, V value) {
-    publish(cache, EventType.EXPIRED, key, /* hasOldValue */ true,
-        /* oldValue */ value, /* newValue */ value, /* quiet */ false);
+    publish(cache, EventType.EXPIRED, key, /* hasOldValue= */ true,
+        /* oldValue= */ value, /* newValue= */ value, /* quiet= */ false);
   }
 
   /**
@@ -185,8 +186,8 @@ public void publishExpired(Cache<K, V> cache, K key, V value) {
    * @param value the entry's value
    */
   public void publishExpiredQuietly(Cache<K, V> cache, K key, V value) {
-    publish(cache, EventType.EXPIRED, key, /* hasOldValue */ true,
-        /* oldValue */ value, /* newValue */ value, /* quiet */ true);
+    publish(cache, EventType.EXPIRED, key, /* hasOldValue= */ true,
+        /* oldValue= */ value, /* newValue= */ value, /* quiet= */ true);
   }
 
   /**
@@ -223,7 +224,7 @@ private void publish(Cache<K, V> cache, EventType eventType, K key,
       return;
     }
 
-    JCacheEntryEvent<K, V> event = null;
+    @Var JCacheEntryEvent<K, V> event = null;
     for (var entry : dispatchQueues.entrySet()) {
       var registration = entry.getKey();
       if (!registration.getCacheEntryListener().isCompatible(eventType)) {
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilter.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilter.java
index c1a870dd5e..915e4910fc 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilter.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilter.java
@@ -70,7 +70,7 @@ public boolean equals(Object o) {
     } else if (!(o instanceof EventTypeFilter<?, ?>)) {
       return false;
     }
-    EventTypeFilter<?, ?> other = (EventTypeFilter<?, ?>) o;
+    var other = (EventTypeFilter<?, ?>) o;
     return Objects.equals(listener, other.listener)
         && Objects.equals(filter, other.filter);
   }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/JCacheEntryEvent.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/JCacheEntryEvent.java
index 0ea9941329..0e62b8d977 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/JCacheEntryEvent.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/event/JCacheEntryEvent.java
@@ -76,7 +76,7 @@ public <T> T unwrap(Class<T> clazz) {
       throw new IllegalArgumentException("Class " + clazz + " is unknown to this implementation");
     }
     @SuppressWarnings("unchecked")
-    T castedEntry = (T) this;
+    var castedEntry = (T) this;
     return castedEntry;
   }
 
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/integration/JCacheLoaderAdapter.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/integration/JCacheLoaderAdapter.java
index 33f9db20f7..9d11aec47d 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/integration/JCacheLoaderAdapter.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/integration/JCacheLoaderAdapter.java
@@ -90,7 +90,7 @@ public void setCache(CacheProxy<K, V> cache) {
         // Subtracts the load time from the get time
         statistics.recordGetTime(start - ticker.read());
       }
-      return new Expirable<>(value, expireTimeMS());
+      return new Expirable<>(value, expireTimeMillis());
     } catch (CacheLoaderException e) {
       throw e;
     } catch (RuntimeException e) {
@@ -107,7 +107,7 @@ public Map<K, Expirable<V>> loadAll(Set<? extends K> keys) {
       Map<K, Expirable<V>> result = delegate.loadAll(keys).entrySet().stream()
           .filter(entry -> (entry.getKey() != null) && (entry.getValue() != null))
           .collect(toUnmodifiableMap(Map.Entry::getKey,
-              entry -> new Expirable<>(entry.getValue(), expireTimeMS())));
+              entry -> new Expirable<>(entry.getValue(), expireTimeMillis())));
       for (var entry : result.entrySet()) {
         dispatcher.publishCreated(cache, entry.getKey(), entry.getValue().get());
       }
@@ -124,7 +124,7 @@ public Map<K, Expirable<V>> loadAll(Set<? extends K> keys) {
     }
   }
 
-  private long expireTimeMS() {
+  private long expireTimeMillis() {
     try {
       Duration duration = expiry.getExpiryForCreation();
       if (duration.isZero()) {
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/management/JmxRegistration.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/management/JmxRegistration.java
index 12e74c8153..25458b7468 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/management/JmxRegistration.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/management/JmxRegistration.java
@@ -35,7 +35,6 @@
  * @author ben.manes@gmail.com (Ben Manes)
  */
 public final class JmxRegistration {
-  public enum MBeanType { Configuration, Statistics }
 
   private JmxRegistration() {}
 
@@ -46,7 +45,7 @@ private JmxRegistration() {}
    * @param mxbean the management bean
    * @param type the mxbean type
    */
-  public static void registerMXBean(Cache<?, ?> cache, Object mxbean, MBeanType type) {
+  public static void registerMxBean(Cache<?, ?> cache, Object mxbean, MBeanType type) {
     MBeanServer server = ManagementFactory.getPlatformMBeanServer();
     ObjectName objectName = getObjectName(cache, type);
     register(server, objectName, mxbean);
@@ -58,7 +57,7 @@ public static void registerMXBean(Cache<?, ?> cache, Object mxbean, MBeanType ty
    * @param cache the cache to unregister
    * @param type the mxbean type
    */
-  public static void unregisterMXBean(Cache<?, ?> cache, MBeanType type) {
+  public static void unregisterMxBean(Cache<?, ?> cache, MBeanType type) {
     MBeanServer server = ManagementFactory.getPlatformMBeanServer();
     ObjectName objectName = getObjectName(cache, type);
     unregister(server, objectName);
@@ -92,7 +91,7 @@ static ObjectName getObjectName(Cache<?, ?> cache, MBeanType type) {
     String cacheManagerName = sanitize(cache.getCacheManager().getURI().toString());
     String cacheName = sanitize(cache.getName());
     String name = String.format(US, "javax.cache:type=Cache%s,CacheManager=%s,Cache=%s",
-        type, cacheManagerName, cacheName);
+        type.formatted(), cacheManagerName, cacheName);
     return newObjectName(name);
   }
 
@@ -109,4 +108,12 @@ static ObjectName newObjectName(String name) {
   static String sanitize(String name) {
     return (name == null) ? "" : name.replaceAll("[,:=\n]", ".");
   }
+
+  public enum MBeanType {
+    CONFIGURATION, STATISTICS;
+
+    private String formatted() {
+      return Character.toUpperCase(name().charAt(0)) + name().toLowerCase(US).substring(1);
+    }
+  }
 }
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntry.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntry.java
index 04247a6bc8..8c2639740f 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntry.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntry.java
@@ -101,7 +101,7 @@ public <T> T unwrap(Class<T> clazz) {
       throw new IllegalArgumentException("Class " + clazz + " is unknown to this implementation");
     }
     @SuppressWarnings("unchecked")
-    T castedEntry = (T) this;
+    var castedEntry = (T) this;
     return castedEntry;
   }
 
diff --git a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/spi/CaffeineCachingProvider.java b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/spi/CaffeineCachingProvider.java
index 5dc3a2672d..bded9d9226 100644
--- a/jcache/src/main/java/com/github/benmanes/caffeine/jcache/spi/CaffeineCachingProvider.java
+++ b/jcache/src/main/java/com/github/benmanes/caffeine/jcache/spi/CaffeineCachingProvider.java
@@ -24,7 +24,6 @@
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.WeakHashMap;
@@ -39,6 +38,7 @@
 import org.osgi.service.component.annotations.Component;
 
 import com.github.benmanes.caffeine.jcache.CacheManagerImpl;
+import com.google.errorprone.annotations.Var;
 import com.google.errorprone.annotations.concurrent.GuardedBy;
 
 /**
@@ -93,16 +93,16 @@ public CacheManager getCacheManager(URI uri, ClassLoader classLoader) {
 
   @Override
   public CacheManager getCacheManager(URI uri, ClassLoader classLoader, Properties properties) {
-    URI managerURI = getManagerUri(uri);
+    URI managerUri = getManagerUri(uri);
     ClassLoader managerClassLoader = getManagerClassLoader(classLoader);
 
     synchronized (cacheManagers) {
-      Map<URI, CacheManager> cacheManagersByURI = cacheManagers.computeIfAbsent(
+      Map<URI, CacheManager> cacheManagersByUri = cacheManagers.computeIfAbsent(
           managerClassLoader, any -> new HashMap<>());
-      return cacheManagersByURI.computeIfAbsent(managerURI, any -> {
+      return cacheManagersByUri.computeIfAbsent(managerUri, any -> {
         Properties managerProperties = (properties == null) ? getDefaultProperties() : properties;
         return new CacheManagerImpl(this, isOsgiComponent,
-            managerURI, managerClassLoader, managerProperties);
+            managerUri, managerClassLoader, managerProperties);
       });
     }
   }
@@ -121,9 +121,9 @@ public void close() {
   public void close(ClassLoader classLoader) {
     synchronized (cacheManagers) {
       ClassLoader managerClassLoader = getManagerClassLoader(classLoader);
-      Map<URI, CacheManager> cacheManagersByURI = cacheManagers.remove(managerClassLoader);
-      if (cacheManagersByURI != null) {
-        for (CacheManager cacheManager : cacheManagersByURI.values()) {
+      Map<URI, CacheManager> cacheManagersByUri = cacheManagers.remove(managerClassLoader);
+      if (cacheManagersByUri != null) {
+        for (CacheManager cacheManager : cacheManagersByUri.values()) {
           cacheManager.close();
         }
       }
@@ -135,14 +135,14 @@ public void close(ClassLoader classLoader) {
   public void close(URI uri, ClassLoader classLoader) {
     synchronized (cacheManagers) {
       ClassLoader managerClassLoader = getManagerClassLoader(classLoader);
-      Map<URI, CacheManager> cacheManagersByURI = cacheManagers.get(managerClassLoader);
+      Map<URI, CacheManager> cacheManagersByUri = cacheManagers.get(managerClassLoader);
 
-      if (cacheManagersByURI != null) {
-        CacheManager cacheManager = cacheManagersByURI.remove(getManagerUri(uri));
+      if (cacheManagersByUri != null) {
+        CacheManager cacheManager = cacheManagersByUri.remove(getManagerUri(uri));
         if (cacheManager != null) {
           cacheManager.close();
         }
-        if (cacheManagersByURI.isEmpty()) {
+        if (cacheManagersByUri.isEmpty()) {
           cacheManagers.remove(managerClassLoader);
         }
       }
@@ -174,8 +174,9 @@ public JCacheClassLoader() {
 
     @Override
     public Class<?> loadClass(String name) throws ClassNotFoundException {
+      @Var ClassNotFoundException error = null;
+
       ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
-      ClassNotFoundException error = null;
       if ((contextClassLoader != null) && (contextClassLoader != DEFAULT_CLASS_LOADER)) {
         try {
           return contextClassLoader.loadClass(name);
@@ -239,7 +240,7 @@ public Class<?> loadClass(String name) throws ClassNotFoundException {
 
     @Override
     public Enumeration<URL> getResources(String name) throws IOException {
-      List<URL> resources = new ArrayList<>();
+      var resources = new ArrayList<URL>();
 
       ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
       if (contextClassLoader != null && contextClassLoader != DEFAULT_CLASS_LOADER) {
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/AbstractJCacheTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/AbstractJCacheTest.java
index 6170b4e788..35cc391efa 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/AbstractJCacheTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/AbstractJCacheTest.java
@@ -89,8 +89,7 @@ public void after() {
 
   /* --------------- Utility methods ------------- */
 
-  @Nullable
-  protected static Expirable<Integer> getExpirable(
+  protected static @Nullable Expirable<Integer> getExpirable(
       CacheProxy<Integer, Integer> cache, Integer key) {
     return cache.cache.getIfPresent(key);
   }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/CacheProxyTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/CacheProxyTest.java
index 0fde1ad476..483170b61f 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/CacheProxyTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/CacheProxyTest.java
@@ -142,7 +142,7 @@ public void setAccessExpireTime_eternal() {
     when(expiry.getExpiryForAccess()).thenReturn(Duration.ETERNAL);
     var expirable = new Expirable<Integer>(KEY_1, 0);
     jcache.setAccessExpireTime(KEY_1, expirable, 0);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(Long.MAX_VALUE);
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(Long.MAX_VALUE);
   }
 
   @Test
@@ -150,13 +150,13 @@ public void setAccessExpireTime_exception() {
     when(expiry.getExpiryForAccess()).thenThrow(IllegalStateException.class);
     var expirable = new Expirable<Integer>(KEY_1, 0);
     jcache.setAccessExpireTime(KEY_1, expirable, 0);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(0);
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(0);
   }
 
   @Test
   public void getWriteExpireTime_exception() {
     when(expiry.getExpiryForCreation()).thenThrow(IllegalStateException.class);
-    long time = jcache.getWriteExpireTimeMS(true);
+    long time = jcache.getWriteexpireTimeMillis(true);
     assertThat(time).isEqualTo(Long.MIN_VALUE);
   }
 
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/JCacheProfiler.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/JCacheProfiler.java
index f94a87cf9d..52dd6878e3 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/JCacheProfiler.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/JCacheProfiler.java
@@ -83,6 +83,7 @@ public void start() {
   }
 
   @CanIgnoreReturnValue
+  @SuppressWarnings("SystemOut")
   private ScheduledFuture<?> scheduleStatusTask() {
     var stopwatch = Stopwatch.createStarted();
     return Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventDispatcherTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventDispatcherTest.java
index 0f5a1c3b7d..7521ba417c 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventDispatcherTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventDispatcherTest.java
@@ -331,7 +331,7 @@ public void awaitSynchronous_nested() {
         pendingFutures.addAll(secondary.pending.get());
 
     var configuration = new MutableCacheEntryListenerConfiguration<>(
-        () -> listener, null, /* isOldValueRequired */ false, /* isSynchronous */ true);
+        () -> listener, null, /* isOldValueRequired= */ false, /* isSynchronous= */ true);
     primary.register(configuration);
     int key = 1;
 
@@ -378,7 +378,7 @@ private void registerAll(EventDispatcher<Integer, Integer> dispatcher) {
   private static final class ConsumingCacheListener implements
       CacheEntryCreatedListener<Integer, Integer>,  CacheEntryUpdatedListener<Integer, Integer>,
       CacheEntryRemovedListener<Integer, Integer>, CacheEntryExpiredListener<Integer, Integer> {
-    Queue<CacheEntryEvent<?, ?>> queue = new ConcurrentLinkedQueue<>();
+    final Queue<CacheEntryEvent<?, ?>> queue = new ConcurrentLinkedQueue<>();
 
     @Override
     public void onCreated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> events) {
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeAwareListenerTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeAwareListenerTest.java
index 635aa986a1..55174b595f 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeAwareListenerTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeAwareListenerTest.java
@@ -55,7 +55,7 @@ public void closed() throws IOException {
     CacheEntryListener<Integer, Integer> listener = Mockito.mock();
     try (var forwarder = new EventTypeAwareListener<>(listener)) {
       forwarder.dispatch(new JCacheEntryEvent<>(cache, EventType.CREATED,
-          /* key */ 1, /* hasOldValue */ false, /* oldValue */ null, /* newValue */ 2));
+          /* key= */ 1, /* hasOldValue= */ false, /* oldValue= */ null, /* newValue= */ 2));
       verifyNoInteractions(listener);
     }
   }
@@ -65,7 +65,7 @@ public void created_failure(Throwable error) throws IOException {
     var listener = Mockito.mock(CacheEntryCreatedListener.class, answer -> { throw error; });
     try (var forwarder = new EventTypeAwareListener<>(listener)) {
       forwarder.dispatch(new JCacheEntryEvent<>(cache, EventType.CREATED,
-          /* key */ 1, /* hasOldValue */ false, /* oldValue */ null, /* newValue */ 2));
+          /* key= */ 1, /* hasOldValue= */ false, /* oldValue= */ null, /* newValue= */ 2));
     }
     verify(listener).onCreated(anyIterable());
   }
@@ -75,7 +75,7 @@ public void updated_failure(Throwable error) throws IOException {
     var listener = Mockito.mock(CacheEntryUpdatedListener.class, answer -> { throw error; });
     try (var forwarder = new EventTypeAwareListener<>(listener)) {
       forwarder.dispatch(new JCacheEntryEvent<>(cache, EventType.UPDATED,
-          /* key */ 1, /* hasOldValue */ true, /* oldValue */ 2, /* newValue */ 3));
+          /* key= */ 1, /* hasOldValue= */ true, /* oldValue= */ 2, /* newValue= */ 3));
     }
     verify(listener).onUpdated(anyIterable());
   }
@@ -85,7 +85,7 @@ public void removed_failure(Throwable error) throws IOException {
     var listener = Mockito.mock(CacheEntryRemovedListener.class, answer -> { throw error; });
     try (var forwarder = new EventTypeAwareListener<>(listener)) {
       forwarder.dispatch(new JCacheEntryEvent<>(cache, EventType.REMOVED,
-          /* key */ 1, /* hasOldValue */ true, /* oldValue */ 2, /* newValue */ null));
+          /* key= */ 1, /* hasOldValue= */ true, /* oldValue= */ 2, /* newValue= */ null));
     }
     verify(listener).onRemoved(anyIterable());
   }
@@ -95,7 +95,7 @@ public void expired_failure(Throwable error) throws IOException {
     var listener = Mockito.mock(CacheEntryExpiredListener.class, answer -> { throw error; });
     try (var forwarder = new EventTypeAwareListener<>(listener)) {
       forwarder.dispatch(new JCacheEntryEvent<>(cache, EventType.EXPIRED,
-          /* key */ 1, /* hasOldValue */ true, /* oldValue */ 2, /* newValue */ null));
+          /* key= */ 1, /* hasOldValue= */ true, /* oldValue= */ 2, /* newValue= */ null));
     }
     verify(listener).onExpired(anyIterable());
   }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilterTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilterTest.java
index 63be4c695c..1cc67e0504 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilterTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/event/EventTypeFilterTest.java
@@ -43,7 +43,7 @@ public void equals_wrongType() {
   @Test
   public void equals_false() {
     CacheEntryCreatedListener<Integer, Integer> created = events -> {};
-    EventTypeFilter<Integer, Integer> other = new EventTypeFilter<>(created, event -> false);
+    var other = new EventTypeFilter<>(created, event -> false);
     assertThat(filter).isNotEqualTo(other);
   }
 
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheAccessExpiryTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheAccessExpiryTest.java
index 09e27678a5..25b3ebbd14 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheAccessExpiryTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheAccessExpiryTest.java
@@ -100,11 +100,11 @@ public void get_absent() {
   public void get_present(boolean eternal) {
     var expirable = getExpirable(jcache, KEY_1);
     if (eternal) {
-      expirable.setExpireTimeMS(Long.MAX_VALUE);
+      expirable.setExpireTimeMillis(Long.MAX_VALUE);
     }
 
     assertThat(jcache.get(KEY_1)).isEqualTo(VALUE_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -127,7 +127,7 @@ public void get_loading_absent() {
     assertThat(jcacheLoading.get(KEY_1)).isEqualTo(KEY_1);
 
     var expirable = getExpirable(jcacheLoading, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -135,11 +135,11 @@ public void get_loading_absent() {
   public void get_loading_present(boolean eternal) {
     var expirable = getExpirable(jcacheLoading, KEY_1);
     if (eternal) {
-      expirable.setExpireTimeMS(Long.MAX_VALUE);
+      expirable.setExpireTimeMillis(Long.MAX_VALUE);
     }
 
     assertThat(jcacheLoading.get(KEY_1)).isEqualTo(VALUE_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -162,7 +162,7 @@ public void getAll_present(boolean eternal) {
     for (Integer key : keys) {
       var expirable = getExpirable(jcacheLoading, key);
       if (eternal) {
-        expirable.setExpireTimeMS(Long.MAX_VALUE);
+        expirable.setExpireTimeMillis(Long.MAX_VALUE);
       }
     }
 
@@ -170,7 +170,7 @@ public void getAll_present(boolean eternal) {
 
     for (Integer key : keys) {
       var expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -192,12 +192,12 @@ public void invoke_absent() {
   public void invoke_present(boolean eternal) {
     var expirable = getExpirable(jcache, KEY_1);
     if (eternal) {
-      expirable.setExpireTimeMS(Long.MAX_VALUE);
+      expirable.setExpireTimeMillis(Long.MAX_VALUE);
     }
 
     Integer result = jcache.invoke(KEY_1, (entry, args) -> entry.getValue());
     assertThat(result).isEqualTo(VALUE_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -223,7 +223,7 @@ public void invokeAll_present() {
 
     for (Integer key : keys) {
       var expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -235,7 +235,7 @@ public void removeConditionally() {
     assertThat(jcache.remove(KEY_1, VALUE_2)).isFalse();
 
     var expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -246,7 +246,7 @@ public void replaceConditionally() {
     assertThat(jcache.replace(KEY_1, VALUE_2, VALUE_3)).isFalse();
 
     var expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCombinedExpiryTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCombinedExpiryTest.java
index 8d536d477e..b773fdcdfa 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCombinedExpiryTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCombinedExpiryTest.java
@@ -100,7 +100,7 @@ public void put_expired() {
 
     jcache.put(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -114,7 +114,7 @@ public void putIfAbsent_expired() {
     assertThat(jcache.putIfAbsent(KEY_1, VALUE_2)).isTrue();
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
     assertThat(expirable.get()).isEqualTo(VALUE_2);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCreationExpiryTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCreationExpiryTest.java
index 3353b3034d..5980bd839d 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCreationExpiryTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheCreationExpiryTest.java
@@ -88,7 +88,7 @@ public void get_expired() {
   public void get_loading_absent() {
     assertThat(jcacheLoading.get(KEY_1)).isEqualTo(KEY_1);
     Expirable<Integer> expirable = getExpirable(jcacheLoading, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -99,7 +99,7 @@ public void get_loading_expired() {
 
     assertThat(jcacheLoading.get(KEY_1)).isEqualTo(KEY_1);
     Expirable<Integer> expirable = getExpirable(jcacheLoading, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -120,7 +120,7 @@ public void get_loading_present() {
 
     assertThat(jcacheLoading.get(KEY_1)).isEqualTo(VALUE_1);
     Expirable<Integer> expirable = getExpirable(jcacheLoading, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   /* --------------- getAndPut --------------- */
@@ -130,7 +130,7 @@ public void getAndPut_absent() {
     assertThat(jcache.getAndPut(KEY_1, VALUE_1)).isNull();
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -141,7 +141,7 @@ public void getAndPut_expired() {
 
     assertThat(jcache.getAndPut(KEY_1, VALUE_1)).isNull();
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -152,7 +152,7 @@ public void getAndPut_present() {
 
     assertThat(jcache.getAndPut(KEY_1, VALUE_2)).isEqualTo(VALUE_1);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   /* --------------- put --------------- */
@@ -162,7 +162,7 @@ public void put_absent() {
     jcache.put(KEY_1, VALUE_1);
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -173,7 +173,7 @@ public void put_expired() {
 
     jcache.put(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -184,7 +184,7 @@ public void put_present() {
 
     jcache.put(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   /* --------------- putAll --------------- */
@@ -195,7 +195,7 @@ public void putAll_absent() {
 
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -208,7 +208,7 @@ public void putAll_expired() {
     jcache.putAll(entries);
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -221,7 +221,7 @@ public void putAll_present() {
     jcache.putAll(entries);
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+      assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
     }
   }
 
@@ -232,7 +232,7 @@ public void putIfAbsent_absent() {
     jcache.putIfAbsent(KEY_1, VALUE_1);
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -244,7 +244,7 @@ public void putIfAbsent_expired() {
     assertThat(jcache.putIfAbsent(KEY_1, VALUE_2)).isTrue();
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
     assertThat(expirable.get()).isEqualTo(VALUE_2);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -263,7 +263,7 @@ public void putIfAbsent_present() {
 
     jcache.putIfAbsent(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   /* --------------- invoke --------------- */
@@ -277,7 +277,7 @@ public void invoke_absent() {
     assertThat(result).isNull();
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -293,7 +293,7 @@ public void invoke_expired() {
     assertThat(result).isNull();
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -309,7 +309,7 @@ public void invoke_present() {
     assertThat(result).isNull();
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   /* --------------- invokeAll --------------- */
@@ -324,7 +324,7 @@ public void invokeAll_absent() {
 
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -342,7 +342,7 @@ public void invokeAll_expired() {
 
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -360,7 +360,7 @@ public void invokeAll_present() {
 
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
     }
   }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheExpiryAndMaximumSizeTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheExpiryAndMaximumSizeTest.java
index 14e801587a..3c58beac97 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheExpiryAndMaximumSizeTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheExpiryAndMaximumSizeTest.java
@@ -69,7 +69,7 @@ protected CaffeineConfiguration<Integer, Integer> getConfiguration() {
 
     configuration.setMaximumSize(OptionalLong.of(MAXIMUM));
     var listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(() -> listener,
-        /* filterFactory */ null, /* isOldValueRequired */ false, /* isSynchronous */ true);
+        /* filterFactory= */ null, /* isOldValueRequired= */ false, /* isSynchronous= */ true);
     configuration.addCacheEntryListenerConfiguration(listenerConfiguration);
     configuration.setExecutorFactory(MoreExecutors::directExecutor);
 
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheUpdateExpiryTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheUpdateExpiryTest.java
index 3a5ffbb0a9..0a8808b8d4 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheUpdateExpiryTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/expiry/JCacheUpdateExpiryTest.java
@@ -85,7 +85,7 @@ public void getAndPut() {
     assertThat(value).isEqualTo(VALUE_1);
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -96,7 +96,7 @@ public void getAndReplace() {
 
     assertThat(jcache.getAndReplace(KEY_1, VALUE_2)).isEqualTo(VALUE_1);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -107,7 +107,7 @@ public void put() {
 
     jcache.put(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()
+    assertThat(expirable.getExpireTimeMillis()
             ).isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -119,7 +119,7 @@ public void putAll() {
     jcache.putAll(entries);
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
@@ -131,7 +131,7 @@ public void replace() {
 
     jcache.replace(KEY_1, VALUE_2);
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -142,7 +142,7 @@ public void replaceConditionally() {
 
     assertThat(jcache.replace(KEY_1, VALUE_1, VALUE_2)).isTrue();
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -153,7 +153,7 @@ public void replaceConditionally_failed() {
 
     assertThat(jcache.replace(KEY_1, VALUE_2, VALUE_3)).isFalse();
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
+    assertThat(expirable.getExpireTimeMillis()).isEqualTo(START_TIME.plus(EXPIRY_DURATION).toMillis());
   }
 
   @Test
@@ -168,7 +168,7 @@ public void invoke() {
     assertThat(result).isNull();
 
     Expirable<Integer> expirable = getExpirable(jcache, KEY_1);
-    assertThat(expirable.getExpireTimeMS())
+    assertThat(expirable.getExpireTimeMillis())
         .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
   }
 
@@ -185,7 +185,7 @@ public void invokeAll() {
 
     for (Integer key : keys) {
       Expirable<Integer> expirable = getExpirable(jcache, key);
-      assertThat(expirable.getExpireTimeMS())
+      assertThat(expirable.getExpireTimeMillis())
           .isEqualTo(currentTime().plus(EXPIRY_DURATION).toMillis());
     }
   }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/issues/Issue1065Test.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/issues/Issue1065Test.java
index 54b3366a4e..637b31f2ea 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/issues/Issue1065Test.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/issues/Issue1065Test.java
@@ -89,7 +89,7 @@ public void before() {
         new MutableConfiguration<String, String>()
             .addCacheEntryListenerConfiguration(new MutableCacheEntryListenerConfiguration<>(
                 FactoryBuilder.factoryOf(new Listener()), FactoryBuilder.factoryOf(event -> true),
-                /* isOldValueRequired */ true, /* isSynchronous */ true))
+                /* isOldValueRequired= */ true, /* isSynchronous= */ true))
             .setCacheLoaderFactory(new FactoryBuilder.SingletonFactory<>(new Loader()))
             .setReadThrough(true));
     executor = Executors.newWorkStealingPool(NUM_THREADS);
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntryTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntryTest.java
index 3b02f16d96..2acc029ab1 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntryTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorEntryTest.java
@@ -29,7 +29,8 @@
  * @author ben.manes@gmail.com (Ben Manes)
  */
 public final class EntryProcessorEntryTest {
-  EntryProcessorEntry<Integer, Integer> entry = new EntryProcessorEntry<>(1, 2, Optional.empty());
+  final EntryProcessorEntry<Integer, Integer> entry =
+      new EntryProcessorEntry<>(1, 2, Optional.empty());
 
   @Test
   public void unwrap_fail() {
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorTest.java
index 359ca98c78..a806d630dd 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/processor/EntryProcessorTest.java
@@ -30,7 +30,6 @@
 import javax.cache.Cache;
 import javax.cache.expiry.CreatedExpiryPolicy;
 import javax.cache.integration.CacheLoader;
-import javax.cache.integration.CacheLoaderException;
 import javax.cache.integration.CacheWriter;
 import javax.cache.processor.MutableEntry;
 
@@ -136,15 +135,11 @@ public void deleteAll(Collection<?> keys) {
   }
 
   final class MapLoader implements CacheLoader<Integer, Integer> {
-
-    @Override
-    public Integer load(Integer key) throws CacheLoaderException {
+    @Override public Integer load(Integer key) {
       loads++;
       return map.get(key);
     }
-
-    @Override
-    public ImmutableMap<Integer, Integer> loadAll(Iterable<? extends Integer> keys) {
+    @Override public ImmutableMap<Integer, Integer> loadAll(Iterable<? extends Integer> keys) {
       return Streams.stream(keys).collect(toImmutableMap(identity(), this::load));
     }
   }
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumSizeTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumSizeTest.java
index ce0e74db51..a441133b66 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumSizeTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumSizeTest.java
@@ -47,8 +47,8 @@ protected CaffeineConfiguration<Integer, Integer> getConfiguration() {
     var configuration = new CaffeineConfiguration<Integer, Integer>();
     configuration.setMaximumSize(OptionalLong.of(MAXIMUM));
     var listenerConfiguration = new MutableCacheEntryListenerConfiguration<Integer, Integer>(
-        () -> listener, /* filterFactory */ null,
-        /* isOldValueRequired */ false, /* isSynchronous */ true);
+        () -> listener, /* filterFactory= */ null,
+        /* isOldValueRequired= */ false, /* isSynchronous= */ true);
     configuration.addCacheEntryListenerConfiguration(listenerConfiguration);
     configuration.setExecutorFactory(MoreExecutors::directExecutor);
     return configuration;
diff --git a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumWeightTest.java b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumWeightTest.java
index bb362094c3..2497598b91 100644
--- a/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumWeightTest.java
+++ b/jcache/src/test/java/com/github/benmanes/caffeine/jcache/size/JCacheMaximumWeightTest.java
@@ -51,8 +51,8 @@ protected CaffeineConfiguration<Integer, Integer> getConfiguration() {
     configuration.setMaximumWeight(OptionalLong.of(MAXIMUM));
     configuration.setWeigherFactory(Optional.of(() -> (key, value) -> value));
     var listenerConfiguration = new MutableCacheEntryListenerConfiguration<Integer, Integer>(
-        () -> listener, /* filterFactory */ null,
-        /* isOldValueRequired */ true, /* isSynchronous */ true);
+        () -> listener, /* filterFactory= */ null,
+        /* isOldValueRequired= */ true, /* isSynchronous= */ true);
     configuration.addCacheEntryListenerConfiguration(listenerConfiguration);
     configuration.setExecutorFactory(MoreExecutors::directExecutor);
     return configuration;
diff --git a/simulator/build.gradle.kts b/simulator/build.gradle.kts
index 13f2f0ee41..cc5684009b 100644
--- a/simulator/build.gradle.kts
+++ b/simulator/build.gradle.kts
@@ -53,6 +53,7 @@ forbiddenApis {
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     disableWarningsInGeneratedCode = true
+    disable("SystemOut")
     nullaway.disable()
   }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulate.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulate.java
index 29b3073be7..f34342de7b 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulate.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulate.java
@@ -19,10 +19,8 @@
 
 import java.nio.file.Path;
 import java.util.Map;
-import java.util.SortedMap;
 import java.util.SortedSet;
 import java.util.Stack;
-import java.util.TreeMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -30,6 +28,8 @@
 import com.github.benmanes.caffeine.cache.simulator.report.csv.PlotCsv;
 import com.github.benmanes.caffeine.cache.simulator.report.csv.PlotCsv.ChartStyle;
 import com.google.common.base.Stopwatch;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
 import com.typesafe.config.ConfigFactory;
 
 import picocli.CommandLine;
@@ -76,14 +76,12 @@ public final class Simulate implements Runnable {
   @Override
   public void run() {
     var baseName = metric.toLowerCase(US).replace(' ', '_');
-    var reports = new TreeMap<Long, Path>();
-    for (long maximumSize : maximumSizes) {
+    var reports = Maps.toMap(maximumSizes, maximumSize -> {
       var stopwatch = Stopwatch.createStarted();
       var report = simulate(baseName, maximumSize);
-      reports.put(maximumSize, report);
-
       System.out.printf(US, "%,d: Executed in %s%n", maximumSize, stopwatch);
-    }
+      return report;
+    });
 
     if (reports.size() == 1) {
       System.out.printf(US, "Did not generate a chart as only one data point%n");
@@ -112,7 +110,7 @@ private Path simulate(String baseName, long maximumSize) {
   }
 
   /** Returns a combined report from the individual runs. */
-  private Path combineReports(String baseName, SortedMap<Long, Path> inputFiles) {
+  private Path combineReports(String baseName, ImmutableMap<Long, Path> inputFiles) {
     var report = outputDir.resolve(baseName + ".csv");
     var combiner = new CombinedCsvReport(inputFiles, metric, report);
     combiner.run();
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulator.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulator.java
index 5d6002e35d..d241fcce8e 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulator.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/Simulator.java
@@ -119,7 +119,7 @@ private void report(TraceReader trace, List<PolicyActor> policies) {
   }
 
   /** Returns a trace reader for the access events. */
-  private TraceReader getTraceReader(BasicSettings settings) {
+  private static TraceReader getTraceReader(BasicSettings settings) {
     if (settings.trace().isSynthetic()) {
       return Synthetic.generate(settings.trace());
     }
@@ -137,7 +137,7 @@ private ImmutableList<PolicyActor> getPolicyActors(Set<Characteristic> character
   }
 
   /** Throws the underlying cause for the simulation failure. */
-  private void throwError(RuntimeException error, Iterable<PolicyActor> policies) {
+  private static void throwError(RuntimeException error, Iterable<PolicyActor> policies) {
     if (!Thread.currentThread().isInterrupted()) {
       throw error;
     }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/clairvoyant/Clairvoyant.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/clairvoyant/Clairvoyant.java
index 84d629da1b..13a8099a54 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/clairvoyant/Clairvoyant.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/clairvoyant/Clairvoyant.java
@@ -24,6 +24,7 @@
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor.KeyOnlyAdmittor;
 import com.github.benmanes.caffeine.cache.simulator.policy.AccessEvent;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
@@ -99,7 +100,7 @@ private static Long2ObjectMap<IntList> readAccessTimes(BasicSettings settings) {
     try (Stream<AccessEvent> events = trace.events()) {
       int[] tick = { 0 };
       events.forEach(event -> {
-        var times = accessTimes.get(event.key());
+        @Var var times = accessTimes.get(event.key());
         if (times == null) {
           times = new IntArrayList();
           accessTimes.put(event.key(), times);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/ClimberResetCountMin4.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/ClimberResetCountMin4.java
index 7e6a753525..4ad3fa6fc6 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/ClimberResetCountMin4.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/ClimberResetCountMin4.java
@@ -17,6 +17,7 @@
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.membership.Membership;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -40,7 +41,7 @@ public final class ClimberResetCountMin4 extends CountMin4 {
 
   public ClimberResetCountMin4(Config config) {
     super(config);
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     doorkeeper = settings.tinyLfu().countMin4().periodic().doorkeeper().enabled()
         ? settings.membership().filter().create(config)
         : Membership.disabled();
@@ -58,7 +59,7 @@ protected void ensureCapacity(long maximumSize) {
 
   @Override
   public int frequency(long e) {
-    int count = super.frequency(e);
+    @Var int count = super.frequency(e);
     if (doorkeeper.mightContain(e)) {
       count++;
     }
@@ -89,7 +90,7 @@ protected void tryReset(boolean added) {
       return;
     }
 
-    int count = 0;
+    @Var int count = 0;
     for (int i = 0; i < table.length; i++) {
       count += Long.bitCount(table[i] & ONE_MASK);
       table[i] = (table[i] >>> 1) & RESET_MASK;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/CountMin4.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/CountMin4.java
index b1a99c36c5..76eafcb31f 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/CountMin4.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/CountMin4.java
@@ -21,6 +21,7 @@
 import com.github.benmanes.caffeine.cache.simulator.admission.Frequency;
 import com.google.common.math.IntMath;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -45,9 +46,9 @@ public abstract class CountMin4 implements Frequency {
    * Creates a frequency sketch that can accurately estimate the popularity of elements given
    * the maximum size of the cache.
    */
-  @SuppressWarnings("this-escape")
+  @SuppressWarnings({"this-escape", "Varifier"})
   protected CountMin4(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     conservative = settings.tinyLfu().conservative();
 
     double countersMultiplier = settings.tinyLfu().countMin4().countersMultiplier();
@@ -62,6 +63,7 @@ protected CountMin4(Config config) {
    *
    * @param maximumSize the maximum size of the cache
    */
+  @SuppressWarnings("Varifier")
   protected void ensureCapacity(long maximumSize) {
     checkArgument(maximumSize >= 0);
     int maximum = (int) Math.min(maximumSize, Integer.MAX_VALUE >>> 1);
@@ -80,10 +82,11 @@ protected void ensureCapacity(long maximumSize) {
    * @return the estimated number of occurrences of the element; possibly zero but never negative
    */
   @Override
+  @SuppressWarnings("Varifier")
   public int frequency(long e) {
     int hash = spread(Long.hashCode(e));
     int start = (hash & 3) << 2;
-    int frequency = Integer.MAX_VALUE;
+    @Var int frequency = Integer.MAX_VALUE;
     for (int i = 0; i < 4; i++) {
       int index = indexOf(hash, i);
       int count = (int) ((table[index] >>> ((start + i) << 2)) & 0xfL);
@@ -119,7 +122,7 @@ void regularIncrement(long e) {
     int index2 = indexOf(hash, 2);
     int index3 = indexOf(hash, 3);
 
-    boolean added = incrementAt(index0, start, step);
+    @Var boolean added = incrementAt(index0, start, step);
     added |= incrementAt(index1, start + 1, step);
     added |= incrementAt(index2, start + 2, step);
     added |= incrementAt(index3, start + 3, step);
@@ -134,7 +137,7 @@ void conservativeIncrement(long e) {
 
     int[] index = new int[4];
     int[] count = new int[4];
-    int min = Integer.MAX_VALUE;
+    @Var int min = Integer.MAX_VALUE;
     for (int i = 0; i < 4; i++) {
       index[i] = indexOf(hash, i);
       count[i] = (int) ((table[index[i]] >>> ((start + i) << 2)) & 0xfL);
@@ -186,7 +189,7 @@ boolean incrementAt(int i, int j, long step) {
    * @return the table index
    */
   int indexOf(int item, int i) {
-    long hash = (item + SEED[i]) * SEED[i];
+    @Var long hash = (item + SEED[i]) * SEED[i];
     hash += (hash >>> 32);
     return ((int) hash) & tableMask;
   }
@@ -195,7 +198,7 @@ int indexOf(int item, int i) {
    * Applies a supplemental hash function to a given hashCode, which defends against poor quality
    * hash functions.
    */
-  int spread(int x) {
+  int spread(@Var int x) {
     x = ((x >>> 16) ^ x) * 0x45d9f3b;
     x = ((x >>> 16) ^ x) * 0x45d9f3b;
     return (x >>> 16) ^ x;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IncrementalResetCountMin4.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IncrementalResetCountMin4.java
index c893773313..e00b812940 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IncrementalResetCountMin4.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IncrementalResetCountMin4.java
@@ -31,7 +31,7 @@ public final class IncrementalResetCountMin4 extends CountMin4 {
 
   public IncrementalResetCountMin4(Config config) {
     super(config);
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     interval = settings.tinyLfu().countMin4().incremental().interval();
     cursor = settings.randomSeed();
   }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IndicatorResetCountMin4.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IndicatorResetCountMin4.java
index 4a97b70fea..9a20080c80 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IndicatorResetCountMin4.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/IndicatorResetCountMin4.java
@@ -62,7 +62,7 @@ private double getIndicator() {
     return indicator.getIndicator();
   }
 
-  private int hintToStep(double ind) {
+  private static int hintToStep(double ind) {
     return (int) (ind * 30);
   }
 
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/PeriodicResetCountMin4.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/PeriodicResetCountMin4.java
index 22d1cea891..91bce3420c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/PeriodicResetCountMin4.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin4/PeriodicResetCountMin4.java
@@ -17,6 +17,7 @@
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.membership.Membership;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -34,8 +35,7 @@ public final class PeriodicResetCountMin4 extends CountMin4 {
 
   public PeriodicResetCountMin4(Config config) {
     super(config);
-
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     doorkeeper = settings.tinyLfu().countMin4().periodic().doorkeeper().enabled()
         ? settings.membership().filter().create(config)
         : Membership.disabled();
@@ -52,7 +52,7 @@ protected void ensureCapacity(long maximumSize) {
 
   @Override
   public int frequency(long e) {
-    int count = super.frequency(e);
+    @Var int count = super.frequency(e);
     if (doorkeeper.mightContain(e)) {
       count++;
     }
@@ -81,7 +81,7 @@ protected void tryReset(boolean added) {
       return;
     }
 
-    int count = 0;
+    @Var int count = 0;
     for (int i = 0; i < table.length; i++) {
       count += Long.bitCount(table[i] & ONE_MASK);
       table[i] = (table[i] >>> 1) & RESET_MASK;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64.java
index 9ca53237fd..afdf342110 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64.java
@@ -17,6 +17,8 @@
 
 import java.util.Random;
 
+import com.google.errorprone.annotations.Var;
+
 /**
  * Count-Min Sketch data structure with optional conservative addition.
  * <p>
@@ -42,22 +44,22 @@ public CountMin64(double eps, double confidence, int seed) {
     // We're using a linear hash functions of the form ((a*x+b) mod p) where a,b are chosen
     // independently for each hash function. However, we can set b = 0 as all it does is shift the
     // results without compromising their uniformity or independence with the other hashes.
-    Random r = new Random(seed);
+    var random = new Random(seed);
     for (int i = 0; i < depth; ++i) {
-      hashA[i] = r.nextInt(Integer.MAX_VALUE);
+      hashA[i] = random.nextInt(Integer.MAX_VALUE);
     }
   }
 
   /** The estimate is correct within epsilon * (total item count), with probability confidence. */
   public long estimateCount(long item) {
-    long count = Long.MAX_VALUE;
+    @Var long count = Long.MAX_VALUE;
     for (int i = 0; i < depth; ++i) {
       count = Math.min(count, table[i][hash(item, i)]);
     }
     return count;
   }
 
-  public void add(boolean conservative, long item, long count) {
+  public void add(long item, long count, boolean conservative) {
     // Actually for negative increments we'll need to use the median instead of minimum, and
     // accuracy will suffer somewhat. Probably makes sense to add an "allow negative increments"
     // parameter to constructor.
@@ -81,7 +83,7 @@ private void conservativeAdd(long item, long count) {
     for (int i = 0; i < depth; ++i) {
       buckets[i] = hash(item, i);
     }
-    long min = table[0][buckets[0]];
+    @Var long min = table[0][buckets[0]];
     for (int i = 1; i < depth; ++i) {
       min = Math.min(min, table[i][buckets[i]]);
     }
@@ -92,7 +94,7 @@ private void conservativeAdd(long item, long count) {
   }
 
   private int hash(long item, int i) {
-    long hash = hashA[i] * item;
+    @Var long hash = hashA[i] * item;
     // A super fast way of computing x mod 2^p-1
     // See http://www.cs.princeton.edu/courses/archive/fall09/cos521/Handouts/universalclasses.pdf
     // page 149, right after Proposition 7.
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64TinyLfu.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64TinyLfu.java
index 455725fffd..94345b24b4 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64TinyLfu.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/countmin64/CountMin64TinyLfu.java
@@ -42,7 +42,7 @@ public final class CountMin64TinyLfu implements Frequency {
   int size;
 
   public CountMin64TinyLfu(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     sketch = new CountMin64(settings.tinyLfu().countMin64().eps(),
         settings.tinyLfu().countMin64().confidence(), settings.randomSeed());
     sampleSize = Math.toIntExact(10 * settings.maximumSize());
@@ -58,7 +58,7 @@ public int frequency(long o) {
   @Override
   public void increment(long o) {
     if (sketch.estimateCount(o) < MAX_COUNT) {
-      sketch.add(conservative, o, 1);
+      sketch.add(o, 1, conservative);
     }
     size += 1;
     resetIfNeeded();
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/perfect/PerfectFrequency.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/perfect/PerfectFrequency.java
index 50f661b430..408806cf47 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/perfect/PerfectFrequency.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/perfect/PerfectFrequency.java
@@ -34,9 +34,9 @@ public final class PerfectFrequency implements Frequency {
   private int size;
 
   public PerfectFrequency(Config config) {
-    BasicSettings settings = new BasicSettings(config);
-    sampleSize = Math.toIntExact(10 * settings.maximumSize());
     counts = new Long2IntOpenHashMap();
+    var settings = new BasicSettings(config);
+    sampleSize = Math.toIntExact(10 * settings.maximumSize());
   }
 
   @Override
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/table/RandomRemovalFrequencyTable.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/table/RandomRemovalFrequencyTable.java
index aaaf6a94e8..6d78e171e3 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/table/RandomRemovalFrequencyTable.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/table/RandomRemovalFrequencyTable.java
@@ -15,16 +15,17 @@
  */
 package com.github.benmanes.caffeine.cache.simulator.admission.table;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.Random;
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Frequency;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
+import it.unimi.dsi.fastutil.longs.Long2IntMap;
+import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+
 /**
  * A probabilistic multiset for estimating the popularity of an element within a time window. The
  * maximum frequency of an element. The size of the sample in relation to the cache size can be
@@ -40,7 +41,7 @@ public final class RandomRemovalFrequencyTable implements Frequency {
   private static final int sampleFactor = 8;
 
   /** a placeholder for TinyTable */
-  private final Map<Long, Integer> table;
+  private final Long2IntMap table;
   /** used to dropped items at random */
   private final Random random;
   /** sum of total items */
@@ -50,10 +51,10 @@ public final class RandomRemovalFrequencyTable implements Frequency {
   private int currSum;
 
   public RandomRemovalFrequencyTable(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     maxSum = Math.toIntExact(sampleFactor * settings.maximumSize());
     random = new Random(settings.randomSeed());
-    table = new HashMap<>(maxSum);
+    table = new Long2IntOpenHashMap(maxSum);
   }
 
   @Override
@@ -64,7 +65,7 @@ public int frequency(long e) {
   @Override
   public void increment(long e) {
     // read and increments value
-    int value = table.getOrDefault(e, 0) + 1;
+    @Var int value = table.getOrDefault(e, 0) + 1;
     // if the value is big enough there is no point in dropping a value, so we just quit
     if (value > sampleFactor) {
       return;
@@ -82,8 +83,8 @@ public void increment(long e) {
     // converge to their true frequency, but I do not think it is worth fixing right now as this is
     // just a model).
     if (currSum == maxSum) {
-      List<Long> array = new ArrayList<>(table.keySet());
-      long itemToRemove = array.get(random.nextInt(array.size()));
+      var array = new LongArrayList(table.keySet());
+      long itemToRemove = array.getLong(random.nextInt(array.size()));
       value = table.remove(itemToRemove);
 
       if (value > 1) {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/HashFunctionParser.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/HashFunctionParser.java
index 3223ec6612..84c781bc4c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/HashFunctionParser.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/HashFunctionParser.java
@@ -16,6 +16,7 @@
 package com.github.benmanes.caffeine.cache.simulator.admission.tinycache;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This is a hash function and parser tp simplify parsing the hash value, it split it to . This
@@ -23,6 +24,7 @@
  *
  * @author gilga1983@gmail.com (Gil Einziger)
  */
+@SuppressWarnings("MemberName")
 final class HashFunctionParser {
   // currently, chain is bounded to be 64.
   private static final int fpSize = 8; // this implementation assumes byte.
@@ -42,8 +44,8 @@ public HashFunctionParser(int nrSets) {
   }
 
   @CanIgnoreReturnValue
-  public HashedItem createHash(long item) {
-    long h = (Seed64 ^ m);
+  public HashedItem createHash(@Var long item) {
+    @Var long h = (Seed64 ^ m);
     item *= m;
     item ^= item >>> r;
     item *= m;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCache.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCache.java
index 74c9f1536a..cc673a984e 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCache.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCache.java
@@ -18,6 +18,7 @@
 import java.util.Random;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This is the TinyCache model that takes advantage of random eviction policy with a ghost cache as
@@ -99,6 +100,7 @@ public boolean addItem(long item) {
     return false;
   }
 
+  @SuppressWarnings("Varifier")
   private boolean selectVictim(int bucketStart) {
     byte victimOffset = (byte) rnd.nextInt(itemsPerSet);
     int victimChain = indexing.getChainAtOffset(
@@ -108,14 +110,13 @@ private boolean selectVictim(int bucketStart) {
     if (indexing.chainExist(chainIndex[hashFunc.fpaux.set], victimChain)) {
       replace(hashFunc.fpaux, (byte) victimChain, bucketStart, victimOffset);
       return true;
-    } else {
-      throw new RuntimeException("Failed to replace");
     }
+    throw new IllegalStateException("Failed to replace");
   }
 
-  private void replaceItems(int idx, long value, int start, int delta) {
+  private void replaceItems(int idx, @Var long value, @Var int start, int delta) {
+    @Var long entry;
     start += idx;
-    long entry;
     do {
       entry = cache[start];
       cache[start] = value;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheAdapter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheAdapter.java
index 7b6985aa71..afb9b16a50 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheAdapter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheAdapter.java
@@ -37,7 +37,7 @@ public final class TinyCacheAdapter implements Frequency {
    * Note that in this implementation there are always 64 items per set.
    */
   public TinyCacheAdapter(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     // number of (independent sets)
     int nrSets = Math.toIntExact(sampleFactor * settings.maximumSize() / 64);
     tcs = new TinyCacheSketch(nrSets, 64,settings.randomSeed());
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheSketch.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheSketch.java
index 51a1640d7b..a1286a308a 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheSketch.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheSketch.java
@@ -18,6 +18,7 @@
 import java.util.Random;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This is the TinyCache sketch that is based on TinySet and TinyTable. It is adopted for fast
@@ -55,9 +56,9 @@ public int countItem(long item) {
     indexing.setChainStart(indexing.getChainStart() + offset);
     indexing.setChainEnd(indexing.getChainEnd() + offset);
 
-    // Gil : I think some of these tests are, I till carefully examine this function when I have
+    // Gil : I think some of these tests are, I will carefully examine this function when I have
     // time. As far as I understand it is working right now.
-    int count = 0;
+    @Var int count = 0;
     while (indexing.getChainStart() <= indexing.getChainEnd()) {
       try {
         if (cache[indexing.getChainStart() % cache.length] == hashFunc.fpaux.fingerprint) {
@@ -105,20 +106,21 @@ public void addItem(long item) {
     replaceItems(idxToAdd, hashFunc.fpaux.fingerprint, bucketStart, 1);
   }
 
+  @SuppressWarnings("Varifier")
   private void selectVictim(int bucketStart) {
     byte victimOffset = (byte) rnd.nextInt(itemsPerSet);
-    int victimChain =
-        indexing.getChainAtOffset(hashFunc.fpaux, chainIndex, lastIndex, victimOffset);
+    int victimChain = indexing.getChainAtOffset(
+        hashFunc.fpaux, chainIndex, lastIndex, victimOffset);
     if (indexing.chainExist(chainIndex[hashFunc.fpaux.set], victimChain)) {
       replace(hashFunc.fpaux, (byte) victimChain, bucketStart, victimOffset);
     } else {
-      throw new RuntimeException("Failed to replace");
+      throw new IllegalStateException("Failed to replace");
     }
   }
 
-  private void replaceItems(int idx, byte value, int start, int delta) {
+  private void replaceItems(int idx, @Var byte value, @Var int start, int delta) {
+    @Var byte entry;
     start += idx;
-    byte entry;
     do {
       entry = cache[start];
       cache[start] = value;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheWithGhostCache.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheWithGhostCache.java
index e5d2f0dc0b..a7c7b69797 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheWithGhostCache.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinyCacheWithGhostCache.java
@@ -18,6 +18,7 @@
 import java.util.Random;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * This is the TinyCache model that takes advantage of random eviction policy with a ghost cache as
@@ -108,6 +109,7 @@ public boolean addItem(long item) {
     return false;
   }
 
+  @SuppressWarnings("Varifier")
   private boolean selectVictim(int bucketStart) {
     byte victimOffset = (byte) rnd.nextInt(itemsPerSet);
     int victimChain = indexing.getChainAtOffset(
@@ -121,18 +123,16 @@ private boolean selectVictim(int bucketStart) {
       if (currItemScore > victimScore) {
         replace(hashFunc.fpaux, (byte) victimChain, bucketStart, victimOffset);
         return true;
-      } else {
-        return false;
       }
-    } else {
-      throw new RuntimeException("Failed to replace");
+      return false;
     }
+    throw new IllegalStateException("Failed to replace");
   }
 
   @SuppressWarnings("PMD.LocalVariableNamingConventions")
-  private void replaceItems(int idx, long value, int start, int delta) {
+  private void replaceItems(int idx, @Var long value, @Var int start, int delta) {
+    @Var long entry;
     start += idx;
-    long entry;
     do {
       entry = cache[start];
       cache[start] = value;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinySetIndexing.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinySetIndexing.java
index 2890adddcb..1df4d0c242 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinySetIndexing.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/admission/tinycache/TinySetIndexing.java
@@ -16,6 +16,7 @@
 package com.github.benmanes.caffeine.cache.simulator.admission.tinycache;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 
 /**
  * An implementation of TinySet's indexing method. A method to index a succinct hash table that is
@@ -39,9 +40,9 @@ final class TinySetIndexing {
 
   public int getChainStart(HashedItem fpaux, long[] chainIndex, long[] isLastIndex) {
     int requiredChainNumber = rank(chainIndex[fpaux.set], fpaux.chainId);
-    int currentChainNumber = rank(isLastIndex[fpaux.set], requiredChainNumber);
-    int currentOffset = requiredChainNumber;
-    long tempIsLastIndex = isLastIndex[fpaux.set] >>> requiredChainNumber;
+    @Var int currentChainNumber = rank(isLastIndex[fpaux.set], requiredChainNumber);
+    @Var int currentOffset = requiredChainNumber;
+    @Var long tempIsLastIndex = isLastIndex[fpaux.set] >>> requiredChainNumber;
     while (currentChainNumber < requiredChainNumber) {
       currentChainNumber += ((int) tempIsLastIndex) & 1;
       currentOffset++;
@@ -57,10 +58,10 @@ public int rank(long index, int bitNum) {
   @CanIgnoreReturnValue
   public int getChain(HashedItem fpaux, long[] chainIndex, long[] isLastIndex) {
     int requiredChainNumber = rank(chainIndex[fpaux.set], fpaux.chainId);
-    int currentChainNumber = rank(isLastIndex[fpaux.set], requiredChainNumber);
-    int currentOffset = requiredChainNumber;
+    @Var int currentChainNumber = rank(isLastIndex[fpaux.set], requiredChainNumber);
+    @Var int currentOffset = requiredChainNumber;
 
-    long tempisLastIndex = isLastIndex[fpaux.set] >>> requiredChainNumber;
+    @Var long tempisLastIndex = isLastIndex[fpaux.set] >>> requiredChainNumber;
     while (currentChainNumber < requiredChainNumber) {
       currentChainNumber += ((int) tempisLastIndex) & 1;
       currentOffset++;
@@ -80,7 +81,7 @@ public int getChain(HashedItem fpaux, long[] chainIndex, long[] isLastIndex) {
   public int getChainAtOffset(HashedItem fpaux,
       long[] chainIndex, long[] isLastIndex, int offset) {
     int nonEmptyChainsToSee = rank(isLastIndex[fpaux.set], offset);
-    int nonEmptyChainSeen = rank(chainIndex[fpaux.set], nonEmptyChainsToSee);
+    @Var int nonEmptyChainSeen = rank(chainIndex[fpaux.set], nonEmptyChainsToSee);
     for (int i = nonEmptyChainsToSee; i <= 64;) {
       if (chainExist(chainIndex[fpaux.set], i)
           && (nonEmptyChainSeen == nonEmptyChainsToSee)) {
@@ -89,7 +90,7 @@ public int getChainAtOffset(HashedItem fpaux,
       i += Math.max(1, nonEmptyChainsToSee - nonEmptyChainSeen);
       nonEmptyChainSeen = rank(chainIndex[fpaux.set], i);
     }
-    throw new RuntimeException("Cannot choose victim!");
+    throw new IllegalStateException("Cannot choose victim!");
   }
 
   public boolean chainExist(long chainIndex, int chainId) {
@@ -113,7 +114,7 @@ public int addItem(HashedItem fpaux, long[] chainIndex, long[] lastIndex) {
   }
 
   @SuppressWarnings("UnnecessaryParentheses")
-  private long extendZero(long isLastIndex, int offset) {
+  private static long extendZero(long isLastIndex, int offset) {
     long constantPartMask = (1L << offset) - 1;
     return (isLastIndex & constantPartMask)
         | ((isLastIndex << 1L)
@@ -122,7 +123,7 @@ private long extendZero(long isLastIndex, int offset) {
   }
 
   @SuppressWarnings("UnnecessaryParentheses")
-  private long shrinkOffset(long isLastIndex, int offset) {
+  private static long shrinkOffset(long isLastIndex, int offset) {
     long conMask = ((1L << offset) - 1);
     return (isLastIndex & conMask) | (((~conMask) & isLastIndex) >>> 1);
   }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/BloomFilter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/BloomFilter.java
index 997c85fbf7..58a646162a 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/BloomFilter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/BloomFilter.java
@@ -22,8 +22,8 @@
 import org.checkerframework.checker.index.qual.NonNegative;
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
-import com.github.benmanes.caffeine.cache.simulator.BasicSettings.MembershipSettings;
 import com.github.benmanes.caffeine.cache.simulator.membership.Membership;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -55,7 +55,7 @@ public BloomFilter() {}
    * probability.
    */
   public BloomFilter(Config config) {
-    MembershipSettings settings = new BasicSettings(config).membership();
+    var settings = new BasicSettings(config).membership();
     ensureCapacity(settings.expectedInsertions(), settings.fpp());
   }
 
@@ -67,6 +67,7 @@ public BloomFilter(Config config) {
    * @param expectedInsertions the number of expected insertions
    * @param fpp the false positive probability, where {@literal 0.0 > fpp < 1.0}
    */
+  @SuppressWarnings("Varifier")
   public void ensureCapacity(@NonNegative long expectedInsertions, @NonNegative double fpp) {
     checkArgument(expectedInsertions >= 0);
     checkArgument(fpp > 0 && fpp < 1);
@@ -126,7 +127,7 @@ boolean setAt(int item, int seedIndex) {
    * Applies a supplemental hash function to a given hashCode, which defends against poor quality
    * hash functions.
    */
-  int spread(int x) {
+  int spread(@Var int x) {
     x = ((x >>> 16) ^ x) * 0x45d9f3b;
     x = ((x >>> 16) ^ x) * 0x45d9f3b;
     return (x >>> 16) ^ x;
@@ -140,7 +141,7 @@ int spread(int x) {
    * @return the table index
    */
   static int seeded(int item, int i) {
-    long hash = (item + SEED[i]) * SEED[i];
+    @Var long hash = (item + SEED[i]) * SEED[i];
     hash += hash >>> 32;
     return (int) hash;
   }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/FastFilter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/FastFilter.java
index 4f7e68e17f..afe2aeba4a 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/FastFilter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/membership/bloom/FastFilter.java
@@ -39,7 +39,7 @@ public final class FastFilter implements Membership {
   private Filter filter;
 
   public FastFilter(Config config) {
-    FastFilterSettings settings = new FastFilterSettings(config);
+    var settings = new FastFilterSettings(config);
     keys = new long[(int) settings.membership().expectedInsertions()];
     filterType = settings.filterType();
     bitsPerKey = settings.bitsPerKey();
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/AbstractTraceReader.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/AbstractTraceReader.java
index 5ba62f34b4..90a8ce37a5 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/AbstractTraceReader.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/AbstractTraceReader.java
@@ -40,6 +40,7 @@
 import com.google.common.base.Throwables;
 import com.google.common.collect.AbstractIterator;
 import com.google.common.collect.Iterators;
+import com.google.errorprone.annotations.Var;
 
 /**
  * A skeletal implementation that reads the trace files into a data stream.
@@ -66,11 +67,11 @@ protected BufferedInputStream readFile() {
 
   @SuppressWarnings("PMD.CloseResource")
   protected BufferedInputStream readInput(InputStream input) {
-    BufferedInputStream buffered = null;
+    @Var BufferedInputStream buffered = null;
     try {
       buffered = new BufferedInputStream(input, BUFFER_SIZE);
-      List<UnaryOperator<InputStream>> extractors = List.of(
-          this::tryXZ, this::tryCompressed, this::tryArchived);
+      var extractors = List.<UnaryOperator<InputStream>>of(
+          AbstractTraceReader::tryXz, AbstractTraceReader::tryCompressed, this::tryArchived);
       for (var extractor : extractors) {
         buffered.mark(100);
         InputStream next = extractor.apply(buffered);
@@ -92,12 +93,12 @@ protected BufferedInputStream readInput(InputStream input) {
         t.addSuppressed(e);
       }
       Throwables.throwIfUnchecked(t);
-      throw new RuntimeException(t);
+      throw new IllegalStateException(t);
     }
   }
 
   /** Returns a uncompressed stream if XZ encoded, else {@code null}. */
-  private @Nullable InputStream tryXZ(InputStream input) {
+  private static @Nullable InputStream tryXz(InputStream input) {
     try {
       return new XZInputStream(input);
     } catch (IOException e) {
@@ -106,7 +107,7 @@ protected BufferedInputStream readInput(InputStream input) {
   }
 
   /** Returns a uncompressed stream, else {@code null}. */
-  private @Nullable InputStream tryCompressed(InputStream input) {
+  private static @Nullable InputStream tryCompressed(InputStream input) {
     try {
       return new CompressorStreamFactory().createCompressorInputStream(input);
     } catch (CompressorException e) {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/BinaryTraceReader.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/BinaryTraceReader.java
index 0eb55ea0f9..248990bd40 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/BinaryTraceReader.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/BinaryTraceReader.java
@@ -48,7 +48,7 @@ protected BinaryTraceReader(String filePath) {
   public Stream<AccessEvent> events() {
     var input = new DataInputStream(readFile());
     var stream = StreamSupport.stream(Spliterators.spliteratorUnknownSize(
-        new TraceIterator(input), ORDERED | NONNULL), /* parallel */ false);
+        new TraceIterator(input), ORDERED | NONNULL), /* parallel= */ false);
     return stream.onClose(() -> Closeables.closeQuietly(input));
   }
 
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/Rewriter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/Rewriter.java
index 76f804ad00..3d27bdc569 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/Rewriter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/Rewriter.java
@@ -28,6 +28,7 @@
 import com.google.common.base.CaseFormat;
 import com.google.common.base.Stopwatch;
 import com.google.common.collect.Lists;
+import com.google.errorprone.annotations.Var;
 
 import picocli.CommandLine;
 import picocli.CommandLine.Command;
@@ -92,8 +93,8 @@ public void run() {
   private static String[] argumentsWithDefaults(String[] args) {
     var params = Lists.newArrayList(args);
     if (!params.contains("--inputFormat")) {
-      boolean found = false;
-      boolean defaultFormat = true;
+      @Var boolean found = false;
+      @Var boolean defaultFormat = true;
       for (int i = 0; i < args.length - 1; i++) {
         if (Objects.equals(args[i], "--inputFiles")) {
           defaultFormat &= args[i + 1].contains(":");
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/wikipedia/WikipediaTraceReader.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/wikipedia/WikipediaTraceReader.java
index 55898b65b2..d9ddf1ad58 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/wikipedia/WikipediaTraceReader.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/parser/wikipedia/WikipediaTraceReader.java
@@ -26,6 +26,7 @@
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
 import com.google.common.hash.Hashing;
+import com.google.errorprone.annotations.Var;
 
 /**
  * A reader for the trace files provided by the <a href="http://www.wikibench.eu">wikibench</a>
@@ -51,7 +52,7 @@ public WikipediaTraceReader(String filePath) {
   @Override
   public LongStream keys() {
     return lines()
-        .map(this::parseRequest)
+        .map(WikipediaTraceReader::parseRequest)
         .filter(Objects::nonNull)
         .mapToLong(path -> Hashing.murmur3_128().hashUnencodedChars(path).asLong());
   }
@@ -66,7 +67,7 @@ public LongStream keys() {
    *  <li>A flag to indicate if the request resulted in a database update or not ('-' or 'save')
    * </ul>
    */
-  private @Nullable String parseRequest(String line) {
+  private static @Nullable String parseRequest(String line) {
     if (!isRead(line)) {
       return null;
     }
@@ -81,18 +82,18 @@ public LongStream keys() {
   }
 
   /** Returns whether the request resulted in a write to the database. */
-  private boolean isRead(String line) {
+  private static boolean isRead(String line) {
     return line.charAt(line.length() - 1) == '-';
   }
 
   /** Returns the request URL. */
-  private String getRequestUrl(String line) {
-    int end = line.length() - 2;
+  private static String getRequestUrl(String line) {
+    @Var int end = line.length() - 2;
     while (line.charAt(end) != ' ') {
       end--;
     }
 
-    int start = end - 1;
+    @Var int start = end - 1;
     while (line.charAt(start) != ' ') {
       start--;
     }
@@ -100,14 +101,14 @@ private String getRequestUrl(String line) {
   }
 
   /** Returns the path segment of the URL. */
-  private String getPath(String url) {
+  private static String getPath(String url) {
     int index = url.indexOf('/', 7);
     if (index == -1) {
       return url;
     }
 
     // Replace the html entities that we want to search for inside paths
-    String cleansed = url.substring(index + 1);
+    @Var String cleansed = url.substring(index + 1);
     for (var replacement : REPLACEMENTS) {
       cleansed = StringUtils.replace(cleansed, replacement.search(), replacement.replace());
     }
@@ -118,7 +119,7 @@ private String getPath(String url) {
    * Returns if the path should be included. The request is ignored if it is a search query, a
    * page revision, related to users or user management, or talk pages.
    */
-  public boolean isAllowed(String path) {
+  public static boolean isAllowed(String path) {
     for (String filter : STARTS_WITH_FILTER) {
       if (path.startsWith(filter)) {
         return false;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/AccessEvent.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/AccessEvent.java
index c7ad23f607..204105ee07 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/AccessEvent.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/AccessEvent.java
@@ -67,7 +67,7 @@ public boolean equals(Object o) {
     } else if (!(o instanceof AccessEvent)) {
       return false;
     }
-    AccessEvent event = (AccessEvent) o;
+    var event = (AccessEvent) o;
     return (key() == event.key())
         && (weight() == event.weight())
         && (hitPenalty() == event.hitPenalty())
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyActor.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyActor.java
index b51d54529b..428d3da9b6 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyActor.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyActor.java
@@ -116,6 +116,7 @@ private final class Finish extends Command {
   }
 
   private abstract class Command implements Runnable {
+    @SuppressWarnings("Interruption")
     @Override public final void run() {
       var name = Thread.currentThread().getName();
       Thread.currentThread().setName(policy.getClass().getSimpleName());
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyStats.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyStats.java
index 06f1005bcd..894af8bb8d 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyStats.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/PolicyStats.java
@@ -67,33 +67,34 @@ public PolicyStats(String format, Object... args) {
     this.name = String.format(US, format, args);
     this.metrics = new LinkedHashMap<>();
 
-    addMetric(Metric.of("Policy", (Supplier<String>) this::name, OBJECT, true));
-    addMetric(Metric.of("Hit Rate", (DoubleSupplier) this::hitRate, PERCENT, true));
-    addMetric(Metric.of("Miss Rate", (DoubleSupplier) this::missRate, PERCENT, true));
-    addMetric(Metric.of("Hits", (LongSupplier) this::hitCount, NUMBER, true));
-    addMetric(Metric.of("Misses", (LongSupplier) this::missCount, NUMBER, true));
-    addMetric(Metric.of("Requests", (LongSupplier) this::requestCount, NUMBER, true));
-    addMetric(Metric.of("Evictions", (LongSupplier) this::evictionCount, NUMBER, true));
+    addMetric(Metric.builder()
+        .name("Policy").addValue(this::name).type(OBJECT).required(true));
+    addMetric(Metric.builder()
+        .name("Hit Rate").addValue(this::hitRate).type(PERCENT).required(true));
+    addMetric(Metric.builder()
+        .name("Miss Rate").addValue(this::missRate).type(PERCENT).required(true));
+    addMetric(Metric.builder()
+        .name("Hits").addValue(this::hitCount).type(NUMBER).required(true));
+    addMetric(Metric.builder()
+        .name("Misses").addValue(this::missCount).type(NUMBER).required(true));
+    addMetric(Metric.builder()
+        .name("Misses").addValue(this::missCount).type(NUMBER).required(true));
+    addMetric(Metric.builder()
+        .name("Requests").addValue(this::requestCount).type(NUMBER).required(true));
+    addMetric(Metric.builder()
+        .name("Evictions").addValue(this::evictionCount).type(NUMBER).required(true));
+
     addPercentMetric("Admit rate",
         () -> (admittedCount + rejectedCount) == 0 ? 0 : admissionRate());
     addMetric(Metric.builder()
-        .value((LongSupplier) this::requestsWeight)
-        .addCharacteristic(WEIGHTED)
-        .name("Requests Weight")
-        .type(NUMBER)
-        .build());
+        .name("Requests Weight").addValue(this::requestsWeight)
+        .type(NUMBER).addCharacteristic(WEIGHTED));
     addMetric(Metric.builder()
-        .value((DoubleSupplier) this::weightedHitRate)
-        .addCharacteristic(WEIGHTED)
-        .name("Weighted Hit Rate")
-        .type(PERCENT)
-        .build());
+        .name("Weighted Hit Rate").addValue(this::weightedHitRate)
+        .addCharacteristic(WEIGHTED).type(PERCENT));
     addMetric(Metric.builder()
-        .value((DoubleSupplier) this::weightedMissRate)
-        .addCharacteristic(WEIGHTED)
-        .name("Weighted Miss Rate")
-        .type(PERCENT)
-        .build());
+        .name("Weighted Miss Rate").addValue(this::weightedMissRate)
+        .type(PERCENT).addCharacteristic(WEIGHTED));
     addPercentMetric("Adaption", this::percentAdaption);
     addMetric("Average Miss Penalty", this::averageMissPenalty);
     addMetric("Average Penalty", this::avergePenalty);
@@ -101,24 +102,25 @@ public PolicyStats(String format, Object... args) {
     addMetric("Time", this::stopwatch);
   }
 
-  public void addMetric(Metric metric) {
+  public void addMetric(Metric.Builder metricBuilder) {
+    var metric = metricBuilder.build();
     metrics.put(metric.name(), requireNonNull(metric));
   }
 
   public void addMetric(String name, Supplier<?> supplier) {
-    addMetric(Metric.builder().name(name).value(supplier).type(OBJECT).build());
+    addMetric(Metric.builder().name(name).value(supplier).type(OBJECT));
   }
 
   public void addMetric(String name, LongSupplier supplier) {
-    addMetric(Metric.builder().name(name).value(supplier).type(NUMBER).build());
+    addMetric(Metric.builder().name(name).value(supplier).type(NUMBER));
   }
 
   public void addMetric(String name, DoubleSupplier supplier) {
-    addMetric(Metric.builder().name(name).value(supplier).type(NUMBER).build());
+    addMetric(Metric.builder().name(name).value(supplier).type(NUMBER));
   }
 
   public void addPercentMetric(String name, DoubleSupplier supplier) {
-    addMetric(Metric.builder().name(name).value(supplier).type(PERCENT).build());
+    addMetric(Metric.builder().name(name).value(supplier).type(PERCENT));
   }
 
   public Map<String, Metric> metrics() {
@@ -330,6 +332,18 @@ public final Builder addCharacteristic(Characteristic characteristic) {
         characteristicsBuilder().add(characteristic);
         return this;
       }
+      @CanIgnoreReturnValue
+      public Builder addValue(Supplier<?> value) {
+        return value(value);
+      }
+      @CanIgnoreReturnValue
+      public Builder addValue(LongSupplier value) {
+        return value(value);
+      }
+      @CanIgnoreReturnValue
+      public Builder addValue(DoubleSupplier value) {
+        return value(value);
+      }
     }
   }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/Registry.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/Registry.java
index 28207f6ab7..04777407e7 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/Registry.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/Registry.java
@@ -140,6 +140,7 @@ private void registerMany(Class<? extends Policy> policyClass,
   }
 
   /** Registers the policy using the specified name. */
+  @SuppressWarnings("InconsistentOverloads")
   private void registerMany(String name, Class<? extends Policy> policyClass,
       Function<Config, Set<Policy>> creator) {
     factories.put(name.trim().toLowerCase(US), Factory.of(policyClass, creator));
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/ArcPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/ArcPolicy.java
index 16b001880f..a036b847ae 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/ArcPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/ArcPolicy.java
@@ -17,6 +17,8 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
@@ -72,7 +74,7 @@ public final class ArcPolicy implements KeyOnlyPolicy {
   private int p;
 
   public ArcPolicy(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.policyStats = new PolicyStats(name());
     this.data = new Long2ObjectOpenHashMap<>();
@@ -152,7 +154,7 @@ private void onMiss(long key) {
     //   REPLACE(p) .
     // Put x at the top of T1 and place it in the cache.
 
-    Node node = new Node(key);
+    var node = new Node(key);
     node.type = QueueType.T1;
 
     int sizeL1 = (sizeT1 + sizeB1);
@@ -237,9 +239,9 @@ private enum QueueType {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
-    QueueType type;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable QueueType type;
 
     Node() {
       this.key = Long.MIN_VALUE;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CarPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CarPolicy.java
index 6eaea1f387..c002e9291f 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CarPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CarPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -59,7 +62,7 @@ public final class CarPolicy implements KeyOnlyPolicy {
   private int p;
 
   public CarPolicy(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.policyStats = new PolicyStats(name());
     this.data = new Long2ObjectOpenHashMap<>();
@@ -92,7 +95,7 @@ private void onHit(Node node) {
     policyStats.recordOperation();
   }
 
-  private void onMiss(long key, Node node) {
+  private void onMiss(long key, @Var Node node) {
     // if (|T1| + |T2| = c) then
     //   /* cache full, replace a page from cache */
     //   replace()
@@ -254,9 +257,10 @@ private enum QueueType {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
-    QueueType type;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable QueueType type;
+
     boolean marked;
 
     Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CartPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CartPolicy.java
index 46efa870e8..a3841074a7 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CartPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/adaptive/CartPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -62,7 +65,7 @@ public final class CartPolicy implements KeyOnlyPolicy {
   private int q;
 
   public CartPolicy(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.policyStats = new PolicyStats(name());
     this.data = new Long2ObjectOpenHashMap<>();
@@ -95,7 +98,7 @@ private void onHit(Node node) {
     policyStats.recordOperation();
   }
 
-  private void onMiss(long key, Node node) {
+  private void onMiss(long key, @Var Node node) {
     // if (|T1| + |T2| = c) then
     //   /* cache full, replace a page from cache */
     //   replace()
@@ -157,7 +160,7 @@ private void onMiss(long key, Node node) {
 
       // Set filter bit of x to "S"
       // nS = nS + 1 /* history hit */
-      node.filter = FilterType.ShortTerm;
+      node.filter = FilterType.SHORT_TERM;
       sizeS++;
     } else if (node.type == QueueType.B1) {
       // Adapt: Increase the target size for the list T1 as: p = min{p + max{1, nS / |B1|}, c}
@@ -173,7 +176,7 @@ private void onMiss(long key, Node node) {
       // Reset the page reference bit of x
       // Set nL = nL + 1.
       // Set type of x to "L".
-      node.filter = FilterType.LongTerm;
+      node.filter = FilterType.LONG_TERM;
       node.marked = false;
       sizeL++;
     } else if (node.type == QueueType.B2) {
@@ -189,7 +192,7 @@ private void onMiss(long key, Node node) {
 
       // Reset the page reference bit of x
       // Set nL = nL + 1
-      node.filter = FilterType.LongTerm;
+      node.filter = FilterType.LONG_TERM;
       node.marked = false;
       sizeL++;
 
@@ -253,15 +256,15 @@ private void demote() {
       }
     }
 
-    while ((headT1.next.filter == FilterType.LongTerm) || headT1.next.marked) {
+    while ((headT1.next.filter == FilterType.LONG_TERM) || headT1.next.marked) {
       policyStats.recordOperation();
       Node node = headT1.next;
       if (node.marked) {
         node.moveToTail(headT1);
         node.marked = false;
 
-        if ((sizeT1 >= Math.max(p + 1, sizeB1)) && (node.filter == FilterType.ShortTerm)) {
-          node.filter = FilterType.LongTerm;
+        if ((sizeT1 >= Math.max(p + 1, sizeB1)) && (node.filter == FilterType.SHORT_TERM)) {
+          node.filter = FilterType.LONG_TERM;
           sizeS--;
           sizeL++;
         }
@@ -316,17 +319,17 @@ private enum QueueType {
   }
 
   private enum FilterType {
-    ShortTerm,
-    LongTerm,
+    SHORT_TERM,
+    LONG_TERM,
   }
 
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
-    QueueType type;
-    FilterType filter;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable QueueType type;
+    @Nullable FilterType filter;
 
     boolean marked;
 
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/CampPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/CampPolicy.java
index 9a6f566c13..ca212f425f 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/CampPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/CampPolicy.java
@@ -22,12 +22,15 @@
 import java.util.Objects;
 import java.util.TreeSet;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.AccessEvent;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
@@ -101,6 +104,7 @@ private void onHit(Node node) {
     }
   }
 
+  @SuppressWarnings("Varifier")
   private int roundedCost(AccessEvent event) {
     // Given a number x, let b be the order of its highest non-zero bit. To round x to precision p,
     // zero out the b − p lower order bits or, in other words, preserve only the p most significant
@@ -136,7 +140,7 @@ private void onMiss(AccessEvent event) {
     int priority = priorityQueue.isEmpty()
         ? roundCost
         : priorityQueue.first().priority + roundCost;
-    var sentinel = sentinelMapping.get(roundCost);
+    @Var var sentinel = sentinelMapping.get(roundCost);
     if (sentinel == null) {
       // checks if new LRU list needs to be created for the rounded cost
       sentinel = new Sentinel(roundCost);
@@ -244,8 +248,8 @@ private static class Node {
     final long key;
 
     Sentinel sentinel;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
 
     int weight;
     int cost;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GDWheelPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GDWheelPolicy.java
index 4545dba327..b7d0bbce41 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GDWheelPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GDWheelPolicy.java
@@ -18,12 +18,15 @@
 import static com.github.benmanes.caffeine.cache.simulator.policy.Policy.Characteristic.WEIGHTED;
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.AccessEvent;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -71,7 +74,7 @@ public GDWheelPolicy(Config config) {
 
   @Override
   public void record(AccessEvent event) {
-    Node node = data.get(event.key());
+    @Var Node node = data.get(event.key());
     policyStats.recordOperation();
     if (node == null) {
       policyStats.recordWeightedMiss(event.weight());
@@ -120,6 +123,7 @@ private int findNextQueue() {
     return -1;
   }
 
+  @SuppressWarnings("Varifier")
   private void migrate(int level) {
     // C[idx] ← (C[idx] + 1) mod NQ
     int hand = (clockHand[level] + 1) % wheel[level].length;
@@ -161,11 +165,12 @@ private void remove(Node node) {
     node.remove();
   }
 
+  @SuppressWarnings("Varifier")
   private void add(AccessEvent event, Node node) {
     // W ← max { i | 0 < i ≤ NW and round(c(p) / NQ^(i-1)) > 0 }
-    int wheelHand = 0;
-    int wheelIndex = 0;
-    long relativeCost = 0;
+    @Var int wheelHand = 0;
+    @Var int wheelIndex = 0;
+    @Var long relativeCost = 0;
     for (int i = 0; i < wheel.length; i++) {
       long penalty = Math.round(event.missPenalty() / cost[i]);
       if (penalty > 0) {
@@ -193,10 +198,10 @@ public void finished() {
     checkState(data.size() <= maximumSize, "%s > %s", data.size(), maximumSize);
     checkState(size == expectedSize, "%s != %s", size, expectedSize);
 
-    int nodes = 0;
+    @Var int nodes = 0;
     for (var costWheel : wheel) {
       for (var sentinel : costWheel) {
-        Node next = sentinel.next;
+        @Var Node next = sentinel.next;
         while (next != sentinel) {
           next = next.next;
           nodes++;
@@ -250,8 +255,8 @@ private static class Node {
     double cost;
     int weight;
 
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
 
     public Node(long key) {
       this.key = key;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GdsfPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GdsfPolicy.java
index a836b50dd2..af83c3a7df 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GdsfPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/greedy_dual/GdsfPolicy.java
@@ -29,6 +29,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -108,7 +109,7 @@ private void onMiss(AccessEvent event) {
     //  – Fr(f) is set to one.
     //  – Pr(f) is computed using Eq. 1 and f is enqueued accordingly.
     //  – Used is increased by Size(f).
-    Node candidate = new Node(event.key(), event.weight(), priorityOf(event, 1));
+    var candidate = new Node(event.key(), event.weight(), priorityOf(event, 1));
     data.put(candidate.key, candidate);
     priorityQueue.add(candidate);
     size += candidate.weight;
@@ -152,7 +153,7 @@ private void evict(Node candidate) {
   }
 
   private Set<Node> getVictims(long weightDifference) {
-    long weightedSize = 0L;
+    @Var long weightedSize = 0L;
     var victims = new LinkedHashSet<Node>();
     for (Node node : priorityQueue) {
       victims.add(node);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPlusPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPlusPolicy.java
index a96e251940..8ba8b21762 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPlusPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPlusPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -77,21 +80,21 @@ public final class ClockProPlusPolicy implements KeyOnlyPolicy {
   // We place all the accessed pages, either hot or cold, into one single list in the order of their
   // accesses. In the list, the pages with small recency are at the list head, and the pages with
   // large recency are at the list tail.
-  private Node listHead;
+  private @Nullable Node listHead;
 
   // Points to the hot page with the largest recency. The position of this hand actually serves as a
   // threshold of being a hot page. Any hot pages swept by the hand turn into cold ones.
-  private Node handHot;
+  private @Nullable Node handHot;
 
   // Points to the last resident cold page (i.e., the farthest one to the list head). Because we
   // always select this cold page for replacement, this is the position where we start to look for a
   // victim page, equivalent to the hand in CLOCK.
-  private Node handCold;
+  private @Nullable Node handCold;
 
   // Points to the last cold page in the test period. This hand is used to terminate the test period
   // of cold pages. The non-resident cold pages swept over by this hand will leave the circular
   // list.
-  private Node handTest;
+  private @Nullable Node handTest;
 
   // Maximum number of resident pages (hot + resident cold)
   private final int maxSize;
@@ -113,7 +116,7 @@ public final class ClockProPlusPolicy implements KeyOnlyPolicy {
   private int maxResColdSize;
 
   public ClockProPlusPolicy(Config config) {
-    ClockProPlusSettings settings = new ClockProPlusSettings(config);
+    var settings = new ClockProPlusSettings(config);
     this.maxSize = Math.toIntExact(settings.maximumSize());
     this.maxNonResSize = (int) (maxSize * settings.nonResidentMultiplier());
     this.minResColdSize = (int) (maxSize * settings.percentMinCold());
@@ -153,7 +156,7 @@ public void finished() {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key, node);
@@ -190,12 +193,12 @@ private void onMiss(Node node) {
   }
 
   /** Records a miss when the hot set is not full. */
-  private void onHotWarmupMiss(Node node) {
+  private static void onHotWarmupMiss(Node node) {
     node.moveToHead(Status.HOT);
   }
 
   /** Records a miss when the cold set is not full. */
-  private void onColdWarmupMiss(Node node) {
+  private static void onColdWarmupMiss(Node node) {
     node.moveToHead(Status.COLD_RES_IN_TEST);
   }
 
@@ -322,7 +325,7 @@ private boolean runHandHot(Node trigger) {
     checkState(handHot.isHot());
     checkState(trigger.isInTest());
 
-    boolean demoted = false;
+    @Var boolean demoted = false;
     while (handHot != trigger) {
       if (handHot.isHot()) {
         // If the reference bit of the hot page pointed to by handHot is unset, we can simply change
@@ -366,7 +369,7 @@ private void runHandTest() {
     nextHandTest();
   }
 
-  private void terminateTestPeriod(Node node) {
+  private static void terminateTestPeriod(Node node) {
     if (!node.isInTest()) {
       return;
     }
@@ -435,7 +438,7 @@ private void organizeHands() {
   }
 
   private void coldTargetAdjust(boolean increase) {
-    int delta = 0;
+    @Var int delta = 0;
     if (increase) {
       if (sizeNonResCold != 0) {
         delta = sizeDemoted / sizeNonResCold;
@@ -499,14 +502,13 @@ private void validateClockStructure() {
   private void validateStatus() {
     checkState(listHead != null);
 
-    int sizeHot;
-    int sizeResCold;
-    int sizeNonResCold;
-    int sizeInTest;
-    int sizeRecentlyDemoted;
-    sizeHot = sizeInTest = sizeResCold = sizeNonResCold = sizeRecentlyDemoted = 0;
+    @Var int sizeHot = 0;
+    @Var int sizeInTest = 0;
+    @Var int sizeResCold = 0;
+    @Var int sizeNonResCold = 0;
+    @Var int sizeRecentlyDemoted = 0;
 
-    Node node = listHead;
+    @Var Node node = listHead;
     do {
       if (node == null) {
         break;
@@ -515,15 +517,15 @@ private void validateStatus() {
       if (node.isHot()) {
         sizeHot++;
       }
+      if (node.isInTest()) {
+        sizeInTest++;
+      }
       if (node.isResidentCold()) {
         sizeResCold++;
       }
       if (!node.isResident()) {
         sizeNonResCold++;
       }
-      if (node.isInTest()) {
-        sizeInTest++;
-      }
       if (node.demoted) {
         sizeRecentlyDemoted++;
       }
@@ -531,14 +533,14 @@ private void validateStatus() {
     } while (node != listHead);
 
     checkState(sizeHot == this.sizeHot);
-    checkState(sizeNonResCold == this.sizeNonResCold);
     checkState(sizeInTest == this.sizeInTest);
     checkState(sizeResCold == this.sizeResCold);
+    checkState(sizeNonResCold == this.sizeNonResCold);
     checkState(sizeRecentlyDemoted == this.sizeDemoted);
     checkState(sizeHot + sizeResCold == maxSize - sizeFree);
     checkState(sizeResCold + sizeFree >= minResColdSize);
-    checkState(sizeResCold <= maxResColdSize);
     checkState(sizeNonResCold <= maxNonResSize);
+    checkState(sizeResCold <= maxResColdSize);
   }
 
   /** Prints out the internal state of the policy. */
@@ -649,7 +651,7 @@ boolean isInClock() {
 
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder(MoreObjects.toStringHelper(this)
+      var sb = new StringBuilder(MoreObjects.toStringHelper(this)
           .add("key", key)
           .add("marked", marked)
           .add("demoted", demoted)
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPolicy.java
index cf8a2730a2..c086361e9b 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -58,21 +61,21 @@ public final class ClockProPolicy implements KeyOnlyPolicy {
   // We place all the accessed pages, either hot or cold, into one single list in the order of their
   // accesses. In the list, the pages with small recency are at the list head, and the pages with
   // large recency are at the list tail.
-  private Node listHead;
+  private @Nullable Node listHead;
 
   // Points to the hot page with the largest recency. The position of this hand actually serves as a
   // threshold of being a hot page. Any hot pages swept by the hand turn into cold ones.
-  private Node handHot;
+  private @Nullable Node handHot;
 
   // Points to the last resident cold page (i.e., the farthest one to the list head). Because we
   // always select this cold page for replacement, this is the position where we start to look for a
   // victim page, equivalent to the hand in CLOCK.
-  private Node handCold;
+  private @Nullable Node handCold;
 
   // Points to the last cold page in the test period. This hand is used to terminate the test period
   // of cold pages. The non-resident cold pages swept over by this hand will leave the circular
   // list.
-  private Node handTest;
+  private @Nullable Node handTest;
 
   // Maximum number of resident pages (hot + resident cold)
   private final int maxSize;
@@ -93,7 +96,7 @@ public final class ClockProPolicy implements KeyOnlyPolicy {
   private int maxResColdSize;
 
   public ClockProPolicy(Config config) {
-    ClockProSettings settings = new ClockProSettings(config);
+    var settings = new ClockProSettings(config);
     this.maxSize = Math.toIntExact(settings.maximumSize());
     this.maxNonResSize = (int) (maxSize * settings.nonResidentMultiplier());
     this.minResColdSize = (int) (maxSize * settings.percentMinCold());
@@ -133,7 +136,7 @@ public void finished() {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key, node);
@@ -170,12 +173,12 @@ private void onMiss(Node node) {
   }
 
   /** Records a miss when the hot set is not full. */
-  private void onHotWarmupMiss(Node node) {
+  private static void onHotWarmupMiss(Node node) {
     node.moveToHead(Status.HOT);
   }
 
   /** Records a miss when the cold set is not full. */
-  private void onColdWarmupMiss(Node node) {
+  private static void onColdWarmupMiss(Node node) {
     node.moveToHead(Status.COLD_RES_IN_TEST);
   }
 
@@ -290,7 +293,7 @@ private boolean runHandHot(Node trigger) {
     checkState(handHot.isHot());
     checkState(trigger.isInTest());
 
-    boolean demoted = false;
+    @Var boolean demoted = false;
     while (handHot != trigger) {
       if (handHot.isHot()) {
         // If the reference bit of the hot page pointed to by handHot is unset, we can simply change
@@ -441,13 +444,12 @@ private void validateClockStructure() {
   private void validateStatus() {
     checkState(listHead != null);
 
-    int sizeHot;
-    int sizeResCold;
-    int sizeNonResCold;
-    int sizeInTest;
-    sizeHot = sizeInTest = sizeResCold = sizeNonResCold = 0;
+    @Var int sizeHot = 0;
+    @Var int sizeInTest = 0;
+    @Var int sizeResCold = 0;
+    @Var int sizeNonResCold = 0;
 
-    Node node = listHead;
+    @Var Node node = listHead;
     do {
       if (node == null) {
         break;
@@ -456,26 +458,26 @@ private void validateStatus() {
       if (node.isHot()) {
         sizeHot++;
       }
+      if (node.isInTest()) {
+        sizeInTest++;
+      }
       if (node.isResidentCold()) {
         sizeResCold++;
       }
       if (!node.isResident()) {
         sizeNonResCold++;
       }
-      if (node.isInTest()) {
-        sizeInTest++;
-      }
       node = node.next;
     } while (node != listHead);
 
     checkState(sizeHot == this.sizeHot);
-    checkState(sizeNonResCold == this.sizeNonResCold);
     checkState(sizeInTest == this.sizeInTest);
     checkState(sizeResCold == this.sizeResCold);
-    checkState(sizeHot + sizeResCold == maxSize - sizeFree);
+    checkState(sizeNonResCold == this.sizeNonResCold);
     checkState(sizeResCold + sizeFree >= minResColdSize);
-    checkState(sizeResCold <= maxResColdSize);
+    checkState(sizeHot + sizeResCold == maxSize - sizeFree);
     checkState(sizeNonResCold <= maxNonResSize);
+    checkState(sizeResCold <= maxResColdSize);
   }
 
   /** Prints out the internal state of the policy. */
@@ -585,7 +587,7 @@ boolean isInClock() {
 
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder(MoreObjects.toStringHelper(this)
+      var sb = new StringBuilder(MoreObjects.toStringHelper(this)
           .add("key", key)
           .add("marked", marked)
           .add("type", status)
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProSimplePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProSimplePolicy.java
index e7743bedf0..1088a3b1cd 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProSimplePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/ClockProSimplePolicy.java
@@ -23,6 +23,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -70,7 +71,7 @@ public final class ClockProSimplePolicy implements KeyOnlyPolicy {
 
   private int sizeHot;
   private int sizeCold;
-  private int sizeNR;
+  private int sizeNonResident;
 
   // To know the order of entries, epoch is used. The epoch is incremented by 1 when a new entry is
   // inserted, or when an existing entry has been re-accessed and moved to the head. The epoch is
@@ -98,7 +99,7 @@ public final class ClockProSimplePolicy implements KeyOnlyPolicy {
   private int coldTarget;
 
   public ClockProSimplePolicy(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.maxSize = Math.toIntExact(settings.maximumSize());
     this.minColdSize = this.maxSize / 100;
     this.maxColdSize = this.maxSize - (this.maxSize / 100);
@@ -120,13 +121,13 @@ public void finished() {
     if (debug) {
       printClock();
     }
-    int cold = (int) data.values().stream()
+    long cold = data.values().stream()
       .filter(node -> node.status == Status.COLD)
       .count();
-    int hot = (int) data.values().stream()
+    long hot = data.values().stream()
       .filter(node -> node.status == Status.HOT)
       .count();
-    int nonResident = (int) data.values().stream()
+    long nonResident = data.values().stream()
       .filter(node -> node.status == Status.NR)
       .count();
 
@@ -134,8 +135,8 @@ public void finished() {
       "Cold: expected %s but was %s", sizeCold, cold);
     checkState(hot == sizeHot,
       "Hot: expected %s but was %s", sizeHot, hot);
-    checkState(nonResident == sizeNR,
-      "NonResident: expected %s but was %s", sizeNR, nonResident);
+    checkState(nonResident == sizeNonResident,
+      "NonResident: expected %s but was %s", sizeNonResident, nonResident);
     checkState(data.size() == (cold + hot + nonResident));
     checkState(cold + hot <= maxSize);
     checkState(nonResident <= maxSize);
@@ -165,7 +166,7 @@ private void onMiss(long key) {
     policyStats.recordOperation();
     policyStats.recordMiss();
     epoch++;
-    Node node = new Node(key, epoch);
+    var node = new Node(key, epoch);
     node.status = Status.COLD;
     node.link(headCold);
     data.put(key, node);
@@ -175,7 +176,7 @@ private void onMiss(long key) {
 
   // Prune removes all non-resident entries whose test period has expired.
   private void prune() {
-    while (sizeNR > 0 && !inTestPeriod(headNonResident.prev)) {
+    while ((sizeNonResident > 0) && !inTestPeriod(headNonResident.prev)) {
       scanNonResident();
     }
   }
@@ -184,7 +185,7 @@ private void onNonResidentMiss(Node node) {
     policyStats.recordOperation();
     policyStats.recordMiss();
     node.unlink();
-    sizeNR--;
+    sizeNonResident--;
     if (canPromote(node)) {
       node.status = Status.HOT;
       node.link(headHot);
@@ -258,13 +259,13 @@ private void scanCold() {
       if (inTestPeriod(victim)) {
         victim.status = Status.NR;
         victim.link(headNonResident);
-        sizeNR++;
+        sizeNonResident++;
       } else {
         data.remove(victim.key);
       }
       // We keep track the number of non-resident cold entries. Once the number exceeds the limit,
       // we terminate the test period of the oldest non-resident entry.
-      while (sizeNR > maxSize) {
+      while (sizeNonResident > maxSize) {
         scanNonResident();
       }
     }
@@ -273,7 +274,7 @@ private void scanCold() {
   // ScanHot demotes a hot entry between the oldest hot entry's epoch and the given epoch.
   // If the demotion was successful it returns true, otherwise it returns false.
   @CanIgnoreReturnValue
-  private boolean scanHot(long epoch) {
+  private boolean scanHot(@Var long epoch) {
     for (Node victim = headHot.prev; victim.epoch <= epoch; victim = headHot.prev) {
       policyStats.recordOperation();
       victim.unlink();
@@ -308,7 +309,7 @@ private void scanNonResident() {
     Node victim = headNonResident.prev;
     victim.unlink();
     data.remove(victim.key);
-    sizeNR--;
+    sizeNonResident--;
     // If a cold entry passes its test period without a re-access, we decrement coldTarget.
     adjustColdTarget(-1);
   }
@@ -344,7 +345,7 @@ private void printClock() {
       }
       System.out.println("** CLOCK-Pro list HOT TAIL (large recency) **");
     }
-    if (sizeNR > 0) {
+    if (sizeNonResident > 0) {
       System.out.println("** CLOCK-Pro list NR HEAD (small recency) **");
       for (Node n = headNonResident.next; n != headNonResident; n = n.next) {
         System.out.println(n);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/DClockPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/DClockPolicy.java
index e271935494..22ae3cd117 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/DClockPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/DClockPolicy.java
@@ -22,6 +22,8 @@
 import java.util.List;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
@@ -80,7 +82,7 @@ public DClockPolicy(DClockSettings settings, double percentActive) {
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    DClockSettings settings = new DClockSettings(config);
+    var settings = new DClockSettings(config);
     return settings.percentActive().stream()
         .map(percentActive -> new DClockPolicy(settings, percentActive))
         .collect(toUnmodifiableSet());
@@ -107,7 +109,7 @@ private void onMiss(long key) {
     // When a page is accessed for the first time, it is added to the head of the inactive list,
     // slides every existing inactive page towards the tail by one slot, and pushes the current
     // tail page out of memory.
-    Node node = new Node(key, Status.INACTIVE);
+    var node = new Node(key, Status.INACTIVE);
     node.appendToHead(headInactive);
     policyStats.recordMiss();
     data.put(key, node);
@@ -220,13 +222,13 @@ public PolicyStats stats() {
 
   @Override
   public void finished() {
-    int active = (int) data.values().stream()
+    long active = data.values().stream()
         .filter(node -> node.status == Status.ACTIVE)
         .count();
-    int inactive = (int) data.values().stream()
+    long inactive = data.values().stream()
         .filter(node -> node.status == Status.INACTIVE)
         .count();
-    int nonResident = (int) data.values().stream()
+    long nonResident = data.values().stream()
         .filter(node -> node.status == Status.NON_RESIDENT)
         .count();
 
@@ -249,10 +251,11 @@ enum Status {
   static final class Node {
     final long key;
 
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
+
     long nonResidentAge;
-    Status status;
-    Node prev;
-    Node next;
 
     public Node() {
       this.key = Integer.MIN_VALUE;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/FrdPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/FrdPolicy.java
index 001f325a5d..a915981bf0 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/FrdPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/FrdPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -60,7 +63,7 @@ public final class FrdPolicy implements KeyOnlyPolicy {
   int residentSize;
 
   public FrdPolicy(Config config) {
-    FrdSettings settings = new FrdSettings(config);
+    var settings = new FrdSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.maximumMainResidentSize = (int) (maximumSize * settings.percentMain());
     this.maximumFilterSize = maximumSize - maximumMainResidentSize;
@@ -73,7 +76,7 @@ public FrdPolicy(Config config) {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key,node);
@@ -105,12 +108,12 @@ private void onMiss(Node node) {
     }
   }
 
-  private void onMainWarmupMiss(Node node) {
+  private static void onMainWarmupMiss(Node node) {
     node.moveToTop(StackType.MAIN);
     node.status = Status.MAIN;
   }
 
-  private void onFilterWarmupMiss(Node node) {
+  private static void onFilterWarmupMiss(Node node) {
     node.moveToTop(StackType.FILTER);
     node.status = Status.FILTER;
   }
@@ -229,12 +232,11 @@ enum StackType {
   final class Node {
     final long key;
 
-    Status status;
-
-    Node prevFilter;
-    Node nextFilter;
-    Node prevMain;
-    Node nextMain;
+    @Nullable Node prevFilter;
+    @Nullable Node nextFilter;
+    @Nullable Node prevMain;
+    @Nullable Node nextMain;
+    @Nullable Status status;
 
     boolean isInFilter;
     boolean isInMain;
@@ -258,46 +260,56 @@ public boolean isInStack(StackType stackType) {
       throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void moveToTop(StackType stackType) {
       if (isInStack(stackType)) {
         removeFrom(stackType);
       }
 
-      if (stackType == StackType.FILTER) {
-        Node next = headFilter.nextFilter;
-        headFilter.nextFilter = this;
-        next.prevFilter = this;
-        this.nextFilter = next;
-        this.prevFilter = headFilter;
-        isInFilter = true;
-      } else if (stackType == StackType.MAIN) {
-        Node next = headMain.nextMain;
-        headMain.nextMain = this;
-        next.prevMain = this;
-        this.nextMain = next;
-        this.prevMain = headMain;
-        isInMain = true;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          Node next = headFilter.nextFilter;
+          headFilter.nextFilter = this;
+          next.prevFilter = this;
+          this.nextFilter = next;
+          this.prevFilter = headFilter;
+          isInFilter = true;
+          return;
+        }
+        case MAIN: {
+          Node next = headMain.nextMain;
+          headMain.nextMain = this;
+          next.prevMain = this;
+          this.nextMain = next;
+          this.prevMain = headMain;
+          isInMain = true;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void removeFrom(StackType stackType) {
       checkState(isInStack(stackType));
 
-      if (stackType == StackType.FILTER) {
-        prevFilter.nextFilter = nextFilter;
-        nextFilter.prevFilter = prevFilter;
-        prevFilter = nextFilter = null;
-        isInFilter = false;
-      } else if (stackType == StackType.MAIN) {
-        prevMain.nextMain = nextMain;
-        nextMain.prevMain = prevMain;
-        prevMain = nextMain = null;
-        isInMain = false;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          prevFilter.nextFilter = nextFilter;
+          nextFilter.prevFilter = prevFilter;
+          prevFilter = nextFilter = null;
+          isInFilter = false;
+          return;
+        }
+        case MAIN: {
+          prevMain.nextMain = nextMain;
+          nextMain.prevMain = prevMain;
+          prevMain = nextMain = null;
+          isInMain = false;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
     @Override
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/HillClimberFrdPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/HillClimberFrdPolicy.java
index db763b8c7c..3d3db9bcf9 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/HillClimberFrdPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/HillClimberFrdPolicy.java
@@ -17,11 +17,14 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -57,7 +60,7 @@ public final class HillClimberFrdPolicy implements KeyOnlyPolicy {
   private boolean increaseWindow;
 
   public HillClimberFrdPolicy(Config config) {
-    FrdSettings settings = new FrdSettings(config);
+    var settings = new FrdSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.maximumMainResidentSize = (int) (maximumSize * settings.percentMain());
     this.maximumFilterSize = maximumSize - maximumMainResidentSize;
@@ -76,7 +79,7 @@ public void record(long key) {
     policyStats.recordOperation();
     adapt();
 
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key, node);
@@ -194,12 +197,12 @@ private void adaptFilterToMain(Node node) {
     residentMain++;
   }
 
-  private void onMainWarmupMiss(Node node) {
+  private static void onMainWarmupMiss(Node node) {
     node.moveToTop(StackType.MAIN);
     node.status = Status.MAIN;
   }
 
-  private void onFilterWarmupMiss(Node node) {
+  private static void onFilterWarmupMiss(Node node) {
     node.moveToTop(StackType.FILTER);
     node.status = Status.FILTER;
   }
@@ -325,12 +328,11 @@ enum StackType {
   final class Node {
     final long key;
 
-    Status status;
-
-    Node prevFilter;
-    Node nextFilter;
-    Node prevMain;
-    Node nextMain;
+    @Nullable Node prevFilter;
+    @Nullable Node nextFilter;
+    @Nullable Node prevMain;
+    @Nullable Node nextMain;
+    @Nullable Status status;
 
     boolean isInFilter;
     boolean isInMain;
@@ -354,46 +356,56 @@ public boolean isInStack(StackType stackType) {
       throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void moveToTop(StackType stackType) {
       if (isInStack(stackType)) {
         removeFrom(stackType);
       }
 
-      if (stackType == StackType.FILTER) {
-        Node next = headFilter.nextFilter;
-        headFilter.nextFilter = this;
-        next.prevFilter = this;
-        this.nextFilter = next;
-        this.prevFilter = headFilter;
-        isInFilter = true;
-      } else if (stackType == StackType.MAIN) {
-        Node next = headMain.nextMain;
-        headMain.nextMain = this;
-        next.prevMain = this;
-        this.nextMain = next;
-        this.prevMain = headMain;
-        isInMain = true;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          Node next = headFilter.nextFilter;
+          headFilter.nextFilter = this;
+          next.prevFilter = this;
+          this.nextFilter = next;
+          this.prevFilter = headFilter;
+          isInFilter = true;
+          break;
+        }
+        case MAIN: {
+          Node next = headMain.nextMain;
+          headMain.nextMain = this;
+          next.prevMain = this;
+          this.nextMain = next;
+          this.prevMain = headMain;
+          isInMain = true;
+          break;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void removeFrom(StackType stackType) {
       checkState(isInStack(stackType));
 
-      if (stackType == StackType.FILTER) {
-        prevFilter.nextFilter = nextFilter;
-        nextFilter.prevFilter = prevFilter;
-        prevFilter = nextFilter = null;
-        isInFilter = false;
-      } else if (stackType == StackType.MAIN) {
-        prevMain.nextMain = nextMain;
-        nextMain.prevMain = prevMain;
-        prevMain = nextMain = null;
-        isInMain = false;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          prevFilter.nextFilter = nextFilter;
+          nextFilter.prevFilter = prevFilter;
+          prevFilter = nextFilter = null;
+          isInFilter = false;
+          break;
+        }
+        case MAIN: {
+          prevMain.nextMain = nextMain;
+          nextMain.prevMain = prevMain;
+          prevMain = nextMain = null;
+          isInMain = false;
+          break;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
     @Override
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/IndicatorFrdPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/IndicatorFrdPolicy.java
index 51e4e62474..a205df24d3 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/IndicatorFrdPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/IndicatorFrdPolicy.java
@@ -17,12 +17,15 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.github.benmanes.caffeine.cache.simulator.policy.sketch.Indicator;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -51,7 +54,7 @@ public final class IndicatorFrdPolicy implements KeyOnlyPolicy {
   int residentMain;
 
   public IndicatorFrdPolicy(Config config) {
-    FrdSettings settings = new FrdSettings(config);
+    var settings = new FrdSettings(config);
     this.period = settings.period();
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.maximumMainResidentSize = (int) (maximumSize * settings.percentMain());
@@ -68,7 +71,7 @@ public void record(long key) {
     policyStats.recordOperation();
     adapt(key);
 
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key, node);
@@ -169,12 +172,12 @@ private void adaptFilterToMain(Node node) {
     residentMain++;
   }
 
-  private void onMainWarmupMiss(Node node) {
+  private static void onMainWarmupMiss(Node node) {
     node.moveToTop(StackType.MAIN);
     node.status = Status.MAIN;
   }
 
-  private void onFilterWarmupMiss(Node node) {
+  private static void onFilterWarmupMiss(Node node) {
     node.moveToTop(StackType.FILTER);
     node.status = Status.FILTER;
   }
@@ -294,12 +297,11 @@ enum StackType {
   final class Node {
     final long key;
 
-    Status status;
-
-    Node prevFilter;
-    Node nextFilter;
-    Node prevMain;
-    Node nextMain;
+    @Nullable Node prevFilter;
+    @Nullable Node nextFilter;
+    @Nullable Node prevMain;
+    @Nullable Node nextMain;
+    @Nullable Status status;
 
     boolean isInFilter;
     boolean isInMain;
@@ -323,46 +325,56 @@ public boolean isInStack(StackType stackType) {
       throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void moveToTop(StackType stackType) {
       if (isInStack(stackType)) {
         removeFrom(stackType);
       }
 
-      if (stackType == StackType.FILTER) {
-        Node next = headFilter.nextFilter;
-        headFilter.nextFilter = this;
-        next.prevFilter = this;
-        this.nextFilter = next;
-        this.prevFilter = headFilter;
-        isInFilter = true;
-      } else if (stackType == StackType.MAIN) {
-        Node next = headMain.nextMain;
-        headMain.nextMain = this;
-        next.prevMain = this;
-        this.nextMain = next;
-        this.prevMain = headMain;
-        isInMain = true;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          Node next = headFilter.nextFilter;
+          headFilter.nextFilter = this;
+          next.prevFilter = this;
+          this.nextFilter = next;
+          this.prevFilter = headFilter;
+          isInFilter = true;
+          return;
+        }
+        case MAIN: {
+          Node next = headMain.nextMain;
+          headMain.nextMain = this;
+          next.prevMain = this;
+          this.nextMain = next;
+          this.prevMain = headMain;
+          isInMain = true;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
+    @SuppressWarnings("PMD.TooFewBranchesForASwitchStatement")
     public void removeFrom(StackType stackType) {
       checkState(isInStack(stackType));
 
-      if (stackType == StackType.FILTER) {
-        prevFilter.nextFilter = nextFilter;
-        nextFilter.prevFilter = prevFilter;
-        prevFilter = nextFilter = null;
-        isInFilter = false;
-      } else if (stackType == StackType.MAIN) {
-        prevMain.nextMain = nextMain;
-        nextMain.prevMain = prevMain;
-        prevMain = nextMain = null;
-        isInMain = false;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case FILTER: {
+          prevFilter.nextFilter = nextFilter;
+          nextFilter.prevFilter = prevFilter;
+          prevFilter = nextFilter = null;
+          isInFilter = false;
+          return;
+        }
+        case MAIN: {
+          prevMain.nextMain = nextMain;
+          nextMain.prevMain = prevMain;
+          prevMain = nextMain = null;
+          isInMain = false;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
     @Override
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/LirsPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/LirsPolicy.java
index 614c14639d..18e7be7127 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/LirsPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/irr/LirsPolicy.java
@@ -20,11 +20,14 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -53,6 +56,7 @@
  * @author ben.manes@gmail.com (Ben Manes)
  */
 @PolicySpec(name = "irr.Lirs")
+@SuppressWarnings("MemberName")
 public final class LirsPolicy implements KeyOnlyPolicy {
   // Enable to print out the internal state
   private static final boolean debug = false;
@@ -75,7 +79,7 @@ public final class LirsPolicy implements KeyOnlyPolicy {
   int residentSize;
 
   public LirsPolicy(Config config) {
-    LirsSettings settings = new LirsSettings(config);
+    var settings = new LirsSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.maximumNonResidentSize = (int) (maximumSize * settings.nonResidentMultiplier());
     this.maximumHotSize = (int) (maximumSize * settings.percentHot());
@@ -90,7 +94,7 @@ public LirsPolicy(Config config) {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       node = new Node(key);
       data.put(key,node);
@@ -178,7 +182,7 @@ private void onLirWarmupMiss(Node node) {
   }
 
   /** Records a miss when the cold set is not full. */
-  private void onHirWarmupMiss(Node node) {
+  private static void onHirWarmupMiss(Node node) {
     node.status = Status.HIR_RESIDENT;
     node.moveToTop(StackType.Q);
   }
@@ -243,7 +247,7 @@ private void pruneStack() {
 
     // Bound the number of non-resident entries. While not described in the paper, the author's
     // reference implementation provides a similar parameter to avoid uncontrolled growth.
-    Node node = headNR.prevNR;
+    @Var Node node = headNR.prevNR;
     while (sizeNR >  maximumNonResidentSize) {
       policyStats.recordOperation();
       Node removed = node;
@@ -358,14 +362,13 @@ enum StackType {
   final class Node {
     final long key;
 
-    Status status;
-
-    Node prevS;
-    Node nextS;
-    Node prevQ;
-    Node nextQ;
-    Node prevNR;
-    Node nextNR;
+    @Nullable Node prevS;
+    @Nullable Node nextS;
+    @Nullable Node prevQ;
+    @Nullable Node nextQ;
+    @Nullable Node prevNR;
+    @Nullable Node nextNR;
+    @Nullable Status status;
 
     boolean isInS;
     boolean isInQ;
@@ -383,27 +386,27 @@ final class Node {
     }
 
     public boolean isInStack(StackType stackType) {
-      if (stackType == StackType.S) {
-        return isInS;
-      } else if (stackType == StackType.Q) {
-        return isInQ;
-      } else if (stackType == StackType.NR) {
-        return isInNR;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case S:
+          return isInS;
+        case Q:
+          return isInQ;
+        case NR:
+          return isInNR;
       }
+      throw new IllegalArgumentException();
     }
 
     public boolean isStackTop(StackType stackType) {
-      if (stackType == StackType.S) {
-        return (headS.nextS == this);
-      } else if (stackType == StackType.Q) {
-        return (headQ.nextQ == this);
-      } else if (stackType == StackType.NR) {
-        return (headNR.nextNR == this);
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case S:
+          return (headS.nextS == this);
+        case Q:
+          return (headQ.nextQ == this);
+        case NR:
+          return (headNR.nextNR == this);
       }
+      throw new IllegalArgumentException();
     }
 
     public void moveToTop(StackType stackType) {
@@ -411,59 +414,71 @@ public void moveToTop(StackType stackType) {
         removeFrom(stackType);
       }
 
-      if (stackType == StackType.S) {
-        Node next = headS.nextS;
-        headS.nextS = this;
-        next.prevS = this;
-        this.nextS = next;
-        this.prevS = headS;
-        isInS = true;
-        sizeS++;
-      } else if (stackType == StackType.Q) {
-        Node next = headQ.nextQ;
-        headQ.nextQ = this;
-        next.prevQ = this;
-        this.nextQ = next;
-        this.prevQ = headQ;
-        isInQ = true;
-        sizeQ++;
-      } else if (stackType == StackType.NR) {
-        Node next = headNR.nextNR;
-        headNR.nextNR = this;
-        next.prevNR = this;
-        this.nextNR = next;
-        this.prevNR = headNR;
-        isInNR = true;
-        sizeNR++;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case S: {
+          Node next = headS.nextS;
+          headS.nextS = this;
+          next.prevS = this;
+          this.nextS = next;
+          this.prevS = headS;
+          isInS = true;
+          sizeS++;
+          return;
+        }
+        case Q: {
+          Node next = headQ.nextQ;
+          headQ.nextQ = this;
+          next.prevQ = this;
+          this.nextQ = next;
+          this.prevQ = headQ;
+          isInQ = true;
+          sizeQ++;
+          return;
+        }
+        case NR: {
+          Node next = headNR.nextNR;
+          headNR.nextNR = this;
+          next.prevNR = this;
+          this.nextNR = next;
+          this.prevNR = headNR;
+          isInNR = true;
+          sizeNR++;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
     public void removeFrom(StackType stackType) {
       checkState(isInStack(stackType));
 
-      if (stackType == StackType.S) {
-        prevS.nextS = nextS;
-        nextS.prevS = prevS;
-        prevS = nextS = null;
-        isInS = false;
-        sizeS--;
-      } else if (stackType == StackType.Q) {
-        prevQ.nextQ = nextQ;
-        nextQ.prevQ = prevQ;
-        prevQ = nextQ = null;
-        isInQ = false;
-        sizeQ--;
-      } else if (stackType == StackType.NR) {
-        prevNR.nextNR = nextNR;
-        nextNR.prevNR = prevNR;
-        prevNR = nextNR = null;
-        isInNR = false;
-        sizeNR--;
-      } else {
-        throw new IllegalArgumentException();
+      switch (stackType) {
+        case S: {
+          prevS.nextS = nextS;
+          nextS.prevS = prevS;
+          prevS = nextS = null;
+          isInS = false;
+          sizeS--;
+          return;
+        }
+        case Q: {
+          prevQ.nextQ = nextQ;
+          nextQ.prevQ = prevQ;
+          prevQ = nextQ = null;
+          isInQ = false;
+          sizeQ--;
+          return;
+        }
+        case NR: {
+          prevNR.nextNR = nextNR;
+          nextNR.prevNR = prevNR;
+          prevNR = nextNR = null;
+          isInNR = false;
+          sizeNR--;
+          return;
+        }
       }
+      throw new IllegalArgumentException();
     }
 
     @Override
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/FrequentlyUsedPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/FrequentlyUsedPolicy.java
index e802e0966f..202d62caa9 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/FrequentlyUsedPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/FrequentlyUsedPolicy.java
@@ -22,6 +22,7 @@
 import java.util.Set;
 
 import org.apache.commons.lang3.StringUtils;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
@@ -30,6 +31,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -50,7 +52,7 @@ public final class FrequentlyUsedPolicy implements KeyOnlyPolicy {
   final int maximumSize;
 
   public FrequentlyUsedPolicy(Admission admission, EvictionPolicy policy, Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.policyStats = new PolicyStats(admission.format(policy.label()));
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.admittor = admission.from(config, policyStats);
@@ -61,7 +63,7 @@ public FrequentlyUsedPolicy(Admission admission, EvictionPolicy policy, Config c
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config, EvictionPolicy policy) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     return settings.admission().stream().map(admission ->
       new FrequentlyUsedPolicy(admission, policy, config)
     ).collect(toUnmodifiableSet());
@@ -105,7 +107,7 @@ private void onMiss(long key) {
     FrequencyNode freq1 = (freq0.next.count == 1)
         ? freq0.next
         : new FrequencyNode(1, freq0);
-    Node node = new Node(key, freq1);
+    var node = new Node(freq1, key);
     policyStats.recordMiss();
     data.put(key, node);
     node.append();
@@ -138,7 +140,7 @@ Node nextVictim(Node candidate) {
     }
 
     // find the lowest that is not the candidate
-    Node victim = freq0.next.nextNode.next;
+    @Var Node victim = freq0.next.nextNode.next;
     if (victim == candidate) {
       victim = (victim.next == victim.prev)
           ? victim.freq.next.nextNode.next
@@ -169,8 +171,8 @@ static final class FrequencyNode {
     final int count;
     final Node nextNode;
 
-    FrequencyNode prev;
-    FrequencyNode next;
+    @Nullable FrequencyNode prev;
+    @Nullable FrequencyNode next;
 
     public FrequencyNode() {
       nextNode = new Node(this);
@@ -212,8 +214,8 @@ static final class Node {
     final long key;
 
     FrequencyNode freq;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
 
     public Node(FrequencyNode freq) {
       this.key = Long.MIN_VALUE;
@@ -222,7 +224,7 @@ public Node(FrequencyNode freq) {
       this.next = this;
     }
 
-    public Node(long key, FrequencyNode freq) {
+    public Node(FrequencyNode freq, long key) {
       this.next = null;
       this.prev = null;
       this.freq = freq;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/LinkedPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/LinkedPolicy.java
index d9391d862d..1d4423b554 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/LinkedPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/LinkedPolicy.java
@@ -22,6 +22,7 @@
 import java.util.Set;
 
 import org.apache.commons.lang3.StringUtils;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
@@ -60,7 +61,7 @@ public LinkedPolicy(Config config, Set<Characteristic> characteristics,
     this.admittor = admission.from(config, policyStats);
     this.weighted = characteristics.contains(WEIGHTED);
 
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     this.data = new Long2ObjectOpenHashMap<>();
     this.maximumSize = settings.maximumSize();
     this.sentinel = new Node();
@@ -70,7 +71,7 @@ public LinkedPolicy(Config config, Set<Characteristic> characteristics,
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config,
       Set<Characteristic> characteristics, EvictionPolicy policy) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     return settings.admission().stream().map(admission ->
       new LinkedPolicy(config, characteristics, admission, policy)
     ).collect(toUnmodifiableSet());
@@ -83,8 +84,8 @@ public PolicyStats stats() {
 
   @Override
   public void record(AccessEvent event) {
-    final int weight = weighted ? event.weight() : 1;
-    final long key = event.key();
+    int weight = weighted ? event.weight() : 1;
+    long key = event.key();
     Node old = data.get(key);
     admittor.record(key);
     if (old == null) {
@@ -93,7 +94,7 @@ public void record(AccessEvent event) {
         policyStats.recordOperation();
         return;
       }
-      Node node = new Node(key, weight, sentinel);
+      var node = new Node(key, weight, sentinel);
       data.put(key, node);
       currentSize += node.weight;
       node.appendToTail();
@@ -215,11 +216,12 @@ public String label() {
   static final class Node {
     final Node sentinel;
 
-    boolean marked;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+
     long key;
     int weight;
+    boolean marked;
 
     /** Creates a new sentinel node. */
     public Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/MultiQueuePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/MultiQueuePolicy.java
index 2c43ce80ad..da09e306aa 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/MultiQueuePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/MultiQueuePolicy.java
@@ -19,11 +19,14 @@
 
 import java.util.Arrays;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap;
@@ -62,7 +65,7 @@ public final class MultiQueuePolicy implements KeyOnlyPolicy {
   private long currentTime;
 
   public MultiQueuePolicy(Config config) {
-    MultiQueueSettings settings = new MultiQueueSettings(config);
+    var settings = new MultiQueueSettings(config);
     maximumSize = Math.toIntExact(settings.maximumSize());
     threshold = new long[settings.numberOfQueues()];
     headQ = new Node[settings.numberOfQueues()];
@@ -79,7 +82,7 @@ public MultiQueuePolicy(Config config) {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node == null) {
       policyStats.recordMiss();
       node = out.remove(key);
@@ -125,7 +128,7 @@ private int queueIndexFor(Node node) {
   }
 
   private void evict() {
-    Node victim = null;
+    @Var Node victim = null;
     for (Node head : headQ) {
       if (head.next != head) {
         victim = head.next;
@@ -152,8 +155,9 @@ public PolicyStats stats() {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+
     int reference;
     int queueIndex;
     long expireTime;
@@ -163,7 +167,7 @@ static final class Node {
     }
 
     static Node sentinel(int queueIndex) {
-      Node node = new Node(Long.MIN_VALUE);
+      var node = new Node(Long.MIN_VALUE);
       node.expireTime = Long.MAX_VALUE;
       node.queueIndex = queueIndex;
       node.prev = node;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/S4LruPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/S4LruPolicy.java
index 5063aecb12..b69adba496 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/S4LruPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/S4LruPolicy.java
@@ -21,6 +21,8 @@
 import java.util.Arrays;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -57,7 +59,7 @@ public final class S4LruPolicy implements KeyOnlyPolicy {
   private final int levels;
 
   public S4LruPolicy(Admission admission, Config config) {
-    S4LruSettings settings = new S4LruSettings(config);
+    var settings = new S4LruSettings(config);
     this.policyStats = new PolicyStats(admission.format(name()));
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.admittor = admission.from(config, policyStats);
@@ -71,7 +73,7 @@ public S4LruPolicy(Admission admission, Config config) {
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     return settings.admission().stream().map(admission ->
       new S4LruPolicy(admission, config)
     ).collect(toUnmodifiableSet());
@@ -106,7 +108,7 @@ private void onHit(Node node) {
   }
 
   private void onMiss(long key) {
-    Node node = new Node(key);
+    var node = new Node(key);
     data.put(key, node);
     node.appendToTail(headQ[0]);
     sizeQ[0]++;
@@ -168,8 +170,9 @@ public PolicyStats stats() {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+
     int level;
 
     Node(long key) {
@@ -177,7 +180,7 @@ static final class Node {
     }
 
     static Node sentinel(int level) {
-      Node node = new Node(Long.MIN_VALUE);
+      var node = new Node(Long.MIN_VALUE);
       node.level = level;
       node.prev = node;
       node.next = node;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SegmentedLruPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SegmentedLruPolicy.java
index a03892c833..1ebbae8d97 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SegmentedLruPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SegmentedLruPolicy.java
@@ -69,8 +69,8 @@ public final class SegmentedLruPolicy implements KeyOnlyPolicy {
   public SegmentedLruPolicy(Admission admission, Config config) {
     this.policyStats = new PolicyStats(admission.format(name()));
     this.admittor = admission.from(config, policyStats);
+    var settings = new SegmentedLruSettings(config);
 
-    SegmentedLruSettings settings = new SegmentedLruSettings(config);
     this.headProtected = new Node();
     this.headProbation = new Node();
     this.data = new Long2ObjectOpenHashMap<>();
@@ -80,7 +80,7 @@ public SegmentedLruPolicy(Admission admission, Config config) {
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     return settings.admission().stream().map(admission ->
       new SegmentedLruPolicy(admission, config)
     ).collect(toUnmodifiableSet());
@@ -118,7 +118,7 @@ private void onHit(Node node) {
   }
 
   private void onMiss(long key) {
-    Node node = new Node(key);
+    var node = new Node(key);
     data.put(key, node);
     policyStats.recordMiss();
     node.appendToTail(headProbation);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SievePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SievePolicy.java
index 2c04bdc874..39cae27f33 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SievePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/linked/SievePolicy.java
@@ -24,6 +24,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -98,7 +99,7 @@ private void onMiss(AccessEvent event) {
   }
 
   private void evict() {
-    var victim = (hand == null) ? tail : hand;
+    @Var var victim = (hand == null) ? tail : hand;
     while ((victim != null) && victim.visited) {
       victim.visited = false;
       victim = (victim.prev == null) ? tail : victim.prev;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/ClairvoyantPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/ClairvoyantPolicy.java
index 1dff1d5e26..098af01c10 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/ClairvoyantPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/ClairvoyantPolicy.java
@@ -52,7 +52,7 @@ public final class ClairvoyantPolicy implements Policy {
   private int tick;
 
   public ClairvoyantPolicy(Config config) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     maximumSize = Math.toIntExact(settings.maximumSize());
     accessTimes = new Long2ObjectOpenHashMap<>();
     policyStats = new PolicyStats(name());
@@ -68,11 +68,8 @@ public void record(AccessEvent event) {
 
     tick++;
     recorder.add(event);
-    IntPriorityQueue times = accessTimes.get(event.key());
-    if (times == null) {
-      times = new IntArrayFIFOQueue();
-      accessTimes.put(event.key(), times);
-    }
+
+    var times = accessTimes.computeIfAbsent(event.key(), key -> new IntArrayFIFOQueue());
     times.enqueue(tick);
   }
 
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/UnboundedPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/UnboundedPolicy.java
index d888be7911..b143f25329 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/UnboundedPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/opt/UnboundedPolicy.java
@@ -43,7 +43,7 @@ public final class UnboundedPolicy implements Policy {
   private final LongSet data;
 
   public UnboundedPolicy(Config config, Set<Characteristic> characteristics) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     int initialSize = characteristics.contains(WEIGHTED)
         ? LongOpenHashSet.DEFAULT_INITIAL_SIZE
         : Ints.saturatedCast(settings.maximumSize());
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/Cache2kPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/Cache2kPolicy.java
index 45f7664294..d9ae2b209c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/Cache2kPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/Cache2kPolicy.java
@@ -48,10 +48,10 @@ public Cache2kPolicy(Config config, Set<Characteristic> characteristics) {
     logger.setLevel(Level.WARNING);
 
     policyStats = new PolicyStats(name());
+    var settings = new BasicSettings(config);
     CacheEntryEvictedListener<Long, AccessEvent> listener =
         (cache, entry) -> policyStats.recordEviction();
-    BasicSettings settings = new BasicSettings(config);
-    Cache2kBuilder<Long, AccessEvent> builder = Cache2kBuilder.of(Long.class, AccessEvent.class)
+    var builder = Cache2kBuilder.of(Long.class, AccessEvent.class)
         .addListener(listener)
         .strictEviction(true);
     if (characteristics.contains(WEIGHTED)) {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CaffeinePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CaffeinePolicy.java
index 87ded91014..58d7cacc65 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CaffeinePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CaffeinePolicy.java
@@ -42,7 +42,7 @@ public final class CaffeinePolicy implements Policy {
 
   public CaffeinePolicy(Config config, Set<Characteristic> characteristics) {
     policyStats = new PolicyStats(name());
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     Caffeine<Long, AccessEvent> builder = Caffeine.newBuilder()
         .removalListener((Long key, AccessEvent value, RemovalCause cause) ->
             policyStats.recordEviction())
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CoherencePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CoherencePolicy.java
index 69c2844f6a..c71a8412ab 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CoherencePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/CoherencePolicy.java
@@ -28,6 +28,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.CaseFormat;
+import com.google.errorprone.annotations.Var;
 import com.tangosol.net.cache.ConfigurableCacheMap.UnitCalculator;
 import com.tangosol.net.cache.LocalCache;
 import com.tangosol.util.MapEvent;
@@ -50,8 +51,8 @@ public CoherencePolicy(CoherenceSettings settings, Eviction policy) {
     policyStats = new PolicyStats(name() + " (%s)", policy);
 
     // auto scale units to integer range (from LocalScheme)
-    int factor = 1;
-    long maximum = settings.maximumSize();
+    @Var int factor = 1;
+    @Var long maximum = settings.maximumSize();
     while (maximum >= Integer.MAX_VALUE) {
       maximum /= 1024;
       factor *= 1024;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/GuavaPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/GuavaPolicy.java
index 06ef463593..446e5c3a1e 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/GuavaPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/GuavaPolicy.java
@@ -40,7 +40,7 @@ public final class GuavaPolicy implements Policy {
 
   public GuavaPolicy(Config config, Set<Characteristic> characteristics) {
     policyStats = new PolicyStats(name());
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     CacheBuilder<Long, AccessEvent> builder = CacheBuilder.newBuilder()
         .removalListener(notification -> policyStats.recordEviction());
     if (characteristics.contains(WEIGHTED)) {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/HazelcastPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/HazelcastPolicy.java
index d7e754e953..e0c73029f7 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/HazelcastPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/product/HazelcastPolicy.java
@@ -65,7 +65,7 @@ public HazelcastPolicy(HazelcastSettings settings, EvictionPolicy policy) {
             .setEvictionPolicy(policy)
             .setSize(maximumSize));
     cache = new DefaultNearCache<>("simulation", config, DummySerializationService.INSTANCE,
-        /* TaskScheduler */ null, getClass().getClassLoader(), /* HazelcastProperties */ null);
+        /* scheduler= */ null, getClass().getClassLoader(), /* properties= */ null);
     cache.initialize();
   }
 
@@ -84,7 +84,7 @@ public void record(long key) {
       if (cache.size() == maximumSize) {
         policyStats.recordEviction();
       }
-      cache.put(key, /* keyData */ null, Boolean.TRUE, /* valueDate */ null);
+      cache.put(key, /* keyData */ null, Boolean.TRUE, /* valueDate= */ null);
       policyStats.recordMiss();
     } else {
       policyStats.recordHit();
@@ -143,7 +143,7 @@ enum DummySerializationService implements SerializationService {
       return (T) data;
     }
     @Override public ManagedContext getManagedContext() {
-      return null;
+      throw new UnsupportedOperationException();
     }
     @Override public <B extends Data> B trimSchema(Data data) {
       return (B) data;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sampled/SampledPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sampled/SampledPolicy.java
index 2ea542c4e8..f3018d1ab3 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sampled/SampledPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sampled/SampledPolicy.java
@@ -35,6 +35,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -69,7 +70,7 @@ public SampledPolicy(Admission admission, EvictionPolicy policy, Config config)
     this.policyStats = new PolicyStats(admission.format("sampled." + policy.label()));
     this.admittor = admission.from(config, policyStats);
 
-    SampledSettings settings = new SampledSettings(config);
+    var settings = new SampledSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.sampleStrategy = settings.sampleStrategy();
     this.random = new Random(settings.randomSeed());
@@ -81,7 +82,7 @@ public SampledPolicy(Admission admission, EvictionPolicy policy, Config config)
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config, EvictionPolicy policy) {
-    BasicSettings settings = new BasicSettings(config);
+    var settings = new BasicSettings(config);
     return settings.admission().stream().map(admission ->
       new SampledPolicy(admission, policy, config)
     ).collect(toUnmodifiableSet());
@@ -94,7 +95,7 @@ public PolicyStats stats() {
 
   @Override
   public void record(long key) {
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     admittor.record(key);
     long now = ++tick;
     if (node == null) {
@@ -159,9 +160,9 @@ public enum Sample {
     RESERVOIR {
       @Override public <E> List<E> sample(E[] elements, E candidate,
           int sampleSize, Random random, PolicyStats policyStats) {
-        List<E> sample = new ArrayList<>(sampleSize);
+        var sample = new ArrayList<E>(sampleSize);
         policyStats.addOperations(elements.length);
-        int count = 0;
+        @Var int count = 0;
         for (E e : elements) {
           if (e == candidate) {
             continue;
@@ -182,7 +183,7 @@ public enum Sample {
     SHUFFLE {
       @Override public <E> List<E> sample(E[] elements, E candidate,
           int sampleSize, Random random, PolicyStats policyStats) {
-        List<E> sample = new ArrayList<>(Arrays.asList(elements));
+        var sample = new ArrayList<E>(Arrays.asList(elements));
         policyStats.addOperations(elements.length);
         Collections.shuffle(sample, random);
         sample.remove(candidate);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/Indicator.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/Indicator.java
index 2195d1ddf4..025e27ee40 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/Indicator.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/Indicator.java
@@ -41,14 +41,13 @@ public final class Indicator {
   private long sample;
 
   public Indicator(Config config) {
+    var settings = new IndicatorSettings(config);
     this.sketch = new PeriodicResetCountMin4(
         ConfigFactory.parseString("maximum-size = 5000").withFallback(config));
-    IndicatorSettings settings = new IndicatorSettings(config);
-    this.sample = 0;
-    this.k = settings.k();
     this.ssSize = settings.ssSize();
     this.estSkew = new EstSkew();
     this.hinter = new Hinter();
+    this.k = settings.k();
   }
 
   public void record(long key) {
@@ -124,8 +123,8 @@ public IntStream getTopK(int k) {
     }
 
     public double estSkew(int k) {
-      SimpleRegression regression = new SimpleRegression();
       int[] idx = { 1 };
+      var regression = new SimpleRegression();
       getTopK(k).forEachOrdered(freq -> regression.addData(Math.log(idx[0]++), Math.log(freq)));
       return -regression.getSlope();
     }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/WindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/WindowTinyLfuPolicy.java
index 989848cd75..a96b5914a8 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/WindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/WindowTinyLfuPolicy.java
@@ -21,6 +21,8 @@
 import java.util.List;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -68,6 +70,7 @@ public final class WindowTinyLfuPolicy implements KeyOnlyPolicy {
   private int sizeWindow;
   private int sizeProtected;
 
+  @SuppressWarnings("Varifier")
   public WindowTinyLfuPolicy(double percentMain, WindowTinyLfuSettings settings) {
     this.policyStats = new PolicyStats(name() + " (%.0f%%)", 100 * (1.0d - percentMain));
     this.admittor = Admission.TINYLFU.from(settings.config(), policyStats);
@@ -84,7 +87,7 @@ public WindowTinyLfuPolicy(double percentMain, WindowTinyLfuSettings settings) {
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    WindowTinyLfuSettings settings = new WindowTinyLfuSettings(config);
+    var settings = new WindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new WindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -120,7 +123,7 @@ public void record(long key) {
   private void onMiss(long key) {
     admittor.record(key);
 
-    Node node = new Node(key, Status.WINDOW);
+    var node = new Node(key, Status.WINDOW);
     node.appendToTail(headWindow);
     data.put(key, node);
     sizeWindow++;
@@ -204,9 +207,9 @@ enum Status {
   static final class Node {
     final long key;
 
-    Status status;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
 
     /** Creates a new sentinel node. */
     public Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimber.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimber.java
index 8bebff41d8..e255468968 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimber.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimber.java
@@ -104,8 +104,8 @@ public String toString() {
         case HOLD: return "0";
         case INCREASE_WINDOW: return "+" + amount;
         case DECREASE_WINDOW: return "-" + amount;
-        default: throw new IllegalStateException();
       }
+      throw new IllegalStateException();
     }
   }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimberWindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimberWindowTinyLfuPolicy.java
index ef80f42816..0a7c760a9c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimberWindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/HillClimberWindowTinyLfuPolicy.java
@@ -41,6 +41,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.sketch.climbing.HillClimber.QueueType;
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -74,8 +75,9 @@ public final class HillClimberWindowTinyLfuPolicy implements KeyOnlyPolicy {
   private double windowSize;
   private double protectedSize;
 
-  public HillClimberWindowTinyLfuPolicy(HillClimberType strategy, double percentMain,
-      HillClimberWindowTinyLfuSettings settings) {
+  @SuppressWarnings("Varifier")
+  public HillClimberWindowTinyLfuPolicy(HillClimberType strategy,
+      double percentMain, HillClimberWindowTinyLfuSettings settings) {
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     int maxMain = (int) (maximumSize * percentMain);
     this.maxProtected = (int) (maxMain * settings.percentMainProtected());
@@ -97,8 +99,8 @@ public HillClimberWindowTinyLfuPolicy(HillClimberType strategy, double percentMa
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    HillClimberWindowTinyLfuSettings settings = new HillClimberWindowTinyLfuSettings(config);
-    Set<Policy> policies = new HashSet<>();
+    var policies = new HashSet<Policy>();
+    var settings = new HillClimberWindowTinyLfuSettings(config);
     for (HillClimberType climber : settings.strategy()) {
       for (double percentMain : settings.percentMain()) {
         policies.add(new HillClimberWindowTinyLfuPolicy(climber, percentMain, settings));
@@ -119,37 +121,44 @@ public void record(long key) {
     Node node = data.get(key);
     admittor.record(key);
 
-    QueueType queue = null;
+    @Var QueueType queue = null;
     if (node == null) {
       onMiss(key);
       policyStats.recordMiss();
     } else {
+      onHit(node);
       queue = node.queue;
-      if (queue == WINDOW) {
-        onWindowHit(node);
-        policyStats.recordHit();
-      } else if (queue == PROBATION) {
-        onProbationHit(node);
-        policyStats.recordHit();
-      } else if (queue == PROTECTED) {
-        onProtectedHit(node);
-        policyStats.recordHit();
-      } else {
-        throw new IllegalStateException();
-      }
     }
     climb(key, queue, isFull);
   }
 
   /** Adds the entry to the admission window, evicting if necessary. */
   private void onMiss(long key) {
-    Node node = new Node(key, WINDOW);
+    var node = new Node(key, WINDOW);
     node.appendToTail(headWindow);
     data.put(key, node);
     windowSize++;
     evict();
   }
 
+  /** Moves or promotes as if necessary. */
+  private void onHit(Node node) {
+    switch (node.queue) {
+      case WINDOW:
+        onWindowHit(node);
+        policyStats.recordHit();
+        return;
+      case PROBATION:
+        onProbationHit(node);
+        policyStats.recordHit();
+        return;
+      case PROTECTED:
+        onProtectedHit(node);
+        policyStats.recordHit();
+        return;
+    }
+  }
+
   /** Moves the entry to the MRU position in the admission window. */
   private void onWindowHit(Node node) {
     node.moveToTail(headWindow);
@@ -311,9 +320,9 @@ public void finished() {
   static final class Node {
     final long key;
 
-    QueueType queue;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable QueueType queue;
 
     /** Creates a new sentinel node. */
     public Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Adam.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Adam.java
index ea082c0811..e76ace274c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Adam.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Adam.java
@@ -39,7 +39,7 @@ public final class Adam extends AbstractClimber {
   private double velocity;
 
   public Adam(Config config) {
-    AdamSettings settings = new AdamSettings(config);
+    var settings = new AdamSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     sampleSize = (int) (settings.percentSample() * maximumSize);
     stepSize = (int) (settings.percentPivot() * maximumSize);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/AmsGrad.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/AmsGrad.java
index 82189b1fed..41b79f87f0 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/AmsGrad.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/AmsGrad.java
@@ -40,7 +40,7 @@ public final class AmsGrad extends AbstractClimber {
   private double maxVelocity;
 
   public AmsGrad(Config config) {
-    AmsGradSettings settings = new AmsGradSettings(config);
+    var settings = new AmsGradSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     sampleSize = (int) (settings.percentSample() * maximumSize);
     stepSize = (int) (settings.percentPivot() * maximumSize);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Nadam.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Nadam.java
index 0fe5c49180..5ea5abd210 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Nadam.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Nadam.java
@@ -40,7 +40,7 @@ public final class Nadam extends AbstractClimber {
   private double velocity;
 
   public Nadam(Config config) {
-    NadamSettings settings = new NadamSettings(config);
+    var settings = new NadamSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     sampleSize = (int) (settings.percentSample() * maximumSize);
     stepSize = (int) (settings.percentPivot() * maximumSize);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Stochastic.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Stochastic.java
index 4c4cb6e329..17b4a99762 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Stochastic.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/gradient/Stochastic.java
@@ -51,7 +51,7 @@ public final class Stochastic extends AbstractClimber {
   private double velocity;
 
   public Stochastic(Config config) {
-    StochasticSettings settings = new StochasticSettings(config);
+    var settings = new StochasticSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     sampleSize = (int) (settings.percentSample() * maximumSize);
     stepSize = (int) (settings.percentPivot() * maximumSize);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimpleClimber.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimpleClimber.java
index 2b29a4fa06..f1738c57f6 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimpleClimber.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimpleClimber.java
@@ -36,7 +36,7 @@ public final class SimpleClimber extends AbstractClimber {
   private double stepSize;
 
   public SimpleClimber(Config config) {
-    SimpleClimberSettings settings = new SimpleClimberSettings(config);
+    var settings = new SimpleClimberSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     this.initialSampleSize = (int) (settings.percentSample() * maximumSize);
     this.initialStepSize = settings.percentPivot() * maximumSize;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimulatedAnnealingClimber.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimulatedAnnealingClimber.java
index a56efde28e..bd2149edfa 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimulatedAnnealingClimber.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/hill/SimulatedAnnealingClimber.java
@@ -39,7 +39,7 @@ public final class SimulatedAnnealingClimber extends AbstractClimber {
   private int stepSize;
 
   public SimulatedAnnealingClimber(Config config) {
-    SimulatedAnnealingSettings settings = new SimulatedAnnealingSettings(config);
+    var settings = new SimulatedAnnealingSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     this.initialStepSize = (int) (settings.percentPivot() * maximumSize);
     this.sampleSize = (int) (settings.percentSample() * maximumSize);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/inference/IndicatorClimber.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/inference/IndicatorClimber.java
index f2dcf0003a..c24da1c69c 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/inference/IndicatorClimber.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/inference/IndicatorClimber.java
@@ -32,7 +32,7 @@ public final class IndicatorClimber implements HillClimber {
   private double prevPercent;
 
   public IndicatorClimber(Config config) {
-    HillClimberWindowTinyLfuSettings settings = new HillClimberWindowTinyLfuSettings(config);
+    var settings = new HillClimberWindowTinyLfuSettings(config);
     this.cacheSize = Math.toIntExact(settings.maximumSize());
     this.prevPercent = 1 - settings.percentMain().get(0);
     this.indicator = new Indicator(config);
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/sim/MiniSimClimber.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/sim/MiniSimClimber.java
index b57ab07d4f..3c74e9f821 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/sim/MiniSimClimber.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/climbing/sim/MiniSimClimber.java
@@ -23,6 +23,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.sketch.climbing.HillClimber;
 import com.google.common.hash.HashFunction;
 import com.google.common.hash.Hashing;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 
@@ -41,19 +42,19 @@ public final class MiniSimClimber implements HillClimber {
 
   private final WindowTinyLfuPolicy[] minis;
   private final long[] prevMisses;
+  private final int samplingRate;
   private final int cacheSize;
   private final int period;
-  private final int R;
 
   private int sample;
   private double prevPercent;
 
   public MiniSimClimber(Config config) {
-    MiniSimSettings settings = new MiniSimSettings(config);
+    var settings = new MiniSimSettings(config);
     this.cacheSize = Math.toIntExact(settings.maximumSize());
-    R = (cacheSize / 1000) > 100 ? 1000 : (cacheSize / 100);
-    WindowTinyLfuSettings simulationSettings = new WindowTinyLfuSettings(ConfigFactory
-        .parseString("maximum-size = " + cacheSize / R)
+    samplingRate = (cacheSize / 1000) > 100 ? 1000 : (cacheSize / 100);
+    var simulationSettings = new WindowTinyLfuSettings(ConfigFactory
+        .parseString("maximum-size = " + (cacheSize / samplingRate))
         .withFallback(config));
     this.prevPercent = 1 - settings.percentMain().get(0);
     this.period = settings.minisimPeriod();
@@ -79,7 +80,7 @@ public void onMiss(long key, boolean isFull) {
   private void onAccess(long key) {
     sample++;
 
-    if (Math.floorMod(hasher.hashLong(key).asInt(), R) < 1) {
+    if (Math.floorMod(hasher.hashLong(key).asInt(), samplingRate) < 1) {
       for (WindowTinyLfuPolicy policy : minis) {
         policy.record(key);
       }
@@ -98,7 +99,7 @@ public Adaptation adapt(double windowSize,
       periodMisses[i] = minis[i].stats().missCount() - prevMisses[i];
       prevMisses[i] = minis[i].stats().missCount();
     }
-    int minIndex = 0;
+    @Var int minIndex = 0;
     for (int i = 1; i < periodMisses.length; i++) {
       if (periodMisses[i] < periodMisses[minIndex]) {
         minIndex = i;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackTinyLfuPolicy.java
index 4926d8931b..34d2e34c76 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackTinyLfuPolicy.java
@@ -19,6 +19,8 @@
 
 import java.util.Map;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -64,7 +66,7 @@ public final class FeedbackTinyLfuPolicy implements KeyOnlyPolicy {
 
   public FeedbackTinyLfuPolicy(Config config) {
     this.policyStats = new PolicyStats(name());
-    FeedbackTinyLfuSettings settings = new FeedbackTinyLfuSettings(config);
+    var settings = new FeedbackTinyLfuSettings(config);
     this.maximumSize = Math.toIntExact(settings.maximumSize());
     this.admittor = Admission.TINYLFU.from(settings.config(), policyStats);
     this.data = new Long2ObjectOpenHashMap<>();
@@ -108,7 +110,7 @@ private void onMiss(long key) {
       admittor.record(key);
     }
 
-    Node node = new Node(key);
+    var node = new Node(key);
     node.appendToTail(head);
     data.put(key, node);
     evict(node);
@@ -181,8 +183,8 @@ public void finished() {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
 
     /** Creates a new sentinel node. */
     public Node() {
@@ -239,10 +241,11 @@ public double adaptiveFpp() {
       return config().getDouble("feedback-tiny-lfu.adaptive-fpp");
     }
     public Config filterConfig(int sampleSize) {
-      Map<String, Object> properties = Map.of(
-          "membership.fpp", adaptiveFpp(),
-          "maximum-size", sampleSize);
-      return ConfigFactory.parseMap(properties).withFallback(config());
+      return ConfigFactory
+          .parseMap(Map.of(
+              "membership.fpp", adaptiveFpp(),
+              "maximum-size", sampleSize))
+          .withFallback(config());
     }
   }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackWindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackWindowTinyLfuPolicy.java
index 934959b537..4a99714b24 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackWindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/feedback/FeedbackWindowTinyLfuPolicy.java
@@ -23,6 +23,8 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -32,6 +34,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 
@@ -80,6 +83,7 @@ public final class FeedbackWindowTinyLfuPolicy implements KeyOnlyPolicy {
   boolean debug;
   boolean trace;
 
+  @SuppressWarnings("Varifier")
   public FeedbackWindowTinyLfuPolicy(double percentMain, FeedbackWindowTinyLfuSettings settings) {
     this.policyStats = new PolicyStats(name() + " (%.0f%%)", 100 * (1.0d - percentMain));
     this.admittor = Admission.TINYLFU.from(settings.config(), policyStats);
@@ -108,7 +112,7 @@ public FeedbackWindowTinyLfuPolicy(double percentMain, FeedbackWindowTinyLfuSett
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    FeedbackWindowTinyLfuSettings settings = new FeedbackWindowTinyLfuSettings(config);
+    var settings = new FeedbackWindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new FeedbackWindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -151,7 +155,7 @@ public void record(long key) {
 
   /** Adds the entry to the admission window, evicting if necessary. */
   private void onMiss(long key) {
-    Node node = new Node(key, Status.WINDOW);
+    var node = new Node(key, Status.WINDOW);
     node.appendToTail(headWindow);
     data.put(key, node);
     sizeWindow++;
@@ -223,7 +227,7 @@ private void evict() {
     }
   }
 
-  private boolean adapt(Node candidate) {
+  private boolean adapt(@Var Node candidate) {
     if (adjusted == sampled) {
       // Already adjusted this period
       return false;
@@ -271,7 +275,7 @@ private boolean adapt(Node candidate) {
       adjusted = sampled;
 
       // Decrease admission window
-      boolean decremented = false;
+      @Var boolean decremented = false;
       for (int i = 0; i < pivotDecrement; i++) {
         if (pivot > 0) {
           pivot--;
@@ -325,9 +329,9 @@ enum Status {
   static final class Node {
     final long key;
 
-    Status status;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
 
     /** Creates a new sentinel node. */
     public Node() {
@@ -410,10 +414,11 @@ public double adaptiveFpp() {
       return config().getDouble("feedback-window-tiny-lfu.adaptive-fpp");
     }
     public Config filterConfig(int sampleSize) {
-      Map<String, Object> properties = Map.of(
-          "membership.fpp", adaptiveFpp(),
-          "maximum-size", sampleSize);
-      return ConfigFactory.parseMap(properties).withFallback(config());
+      return ConfigFactory
+          .parseMap(Map.of(
+              "membership.fpp", adaptiveFpp(),
+              "maximum-size", sampleSize))
+          .withFallback(config());
     }
   }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/FullySegmentedWindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/FullySegmentedWindowTinyLfuPolicy.java
index 1794e931ec..532a942b97 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/FullySegmentedWindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/FullySegmentedWindowTinyLfuPolicy.java
@@ -21,6 +21,8 @@
 import java.util.List;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -61,6 +63,7 @@ public final class FullySegmentedWindowTinyLfuPolicy implements KeyOnlyPolicy {
   private int sizeWindowProtected;
   private int sizeMainProtected;
 
+  @SuppressWarnings("Varifier")
   public FullySegmentedWindowTinyLfuPolicy(
       double percentMain, FullySegmentedWindowTinyLfuSettings settings) {
     this.policyStats = new PolicyStats(name() + " (%.0f%%)", 100 * (1.0d - percentMain));
@@ -79,7 +82,7 @@ public FullySegmentedWindowTinyLfuPolicy(
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    FullySegmentedWindowTinyLfuSettings settings = new FullySegmentedWindowTinyLfuSettings(config);
+    var settings = new FullySegmentedWindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new FullySegmentedWindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -118,7 +121,7 @@ public void record(long key) {
 
   /** Adds the entry to the admission window, evicting if necessary. */
   private void onMiss(long key) {
-    Node node = new Node(key, Status.WINDOW_PROBATION);
+    var node = new Node(key, Status.WINDOW_PROBATION);
     node.appendToTail(headWindowProbation);
     data.put(key, node);
     sizeWindow++;
@@ -219,9 +222,9 @@ enum Status {
   static final class Node {
     final long key;
 
-    Status status;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
 
     /** Creates a new sentinel node. */
     public Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/LruWindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/LruWindowTinyLfuPolicy.java
index 401d884b46..8d11d526bd 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/LruWindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/LruWindowTinyLfuPolicy.java
@@ -21,6 +21,8 @@
 import java.util.List;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -29,6 +31,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -66,7 +69,7 @@ public LruWindowTinyLfuPolicy(double percentMain, LruWindowTinyLfuSettings setti
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    LruWindowTinyLfuSettings settings = new LruWindowTinyLfuSettings(config);
+    var settings = new LruWindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new LruWindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -80,7 +83,7 @@ public PolicyStats stats() {
   @Override
   public void record(long key) {
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     admittor.record(key);
 
     if (node == null) {
@@ -142,9 +145,9 @@ enum Status {
   static final class Node {
     final long key;
 
-    Status status;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
 
     /** Creates a new sentinel node. */
     public Node() {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/RandomWindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/RandomWindowTinyLfuPolicy.java
index c98be82fd7..d86dee4b1f 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/RandomWindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/RandomWindowTinyLfuPolicy.java
@@ -29,6 +29,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -52,6 +53,7 @@ public final class RandomWindowTinyLfuPolicy implements KeyOnlyPolicy {
   int windowSize;
   int mainSize;
 
+  @SuppressWarnings("Varifier")
   public RandomWindowTinyLfuPolicy(double percentMain, RandomWindowTinyLfuSettings settings) {
     policyStats = new PolicyStats(name() + " (%.0f%%)", 100 * (1.0d - percentMain));
     maximumSize = Math.toIntExact(settings.maximumSize());
@@ -66,7 +68,7 @@ public RandomWindowTinyLfuPolicy(double percentMain, RandomWindowTinyLfuSettings
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    RandomWindowTinyLfuSettings settings = new RandomWindowTinyLfuSettings(config);
+    var settings = new RandomWindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new RandomWindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -79,7 +81,7 @@ public PolicyStats stats() {
 
   @Override
   public void record(long key) {
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     admittor.record(key);
     if (node == null) {
       node = new Node(key, windowSize);
@@ -121,7 +123,7 @@ private void evict() {
   }
 
   /** Removes the node from the table and adds the index to the free list. */
-  private void removeFromTable(Node[] table, Node node) {
+  private static void removeFromTable(Node[] table, Node node) {
     int last = table.length - 1;
     table[node.index] = table[last];
     table[node.index].index = node.index;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/S4WindowTinyLfuPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/S4WindowTinyLfuPolicy.java
index 4b380f69ad..3aab28286d 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/S4WindowTinyLfuPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/segment/S4WindowTinyLfuPolicy.java
@@ -22,6 +22,8 @@
 import java.util.List;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admission;
 import com.github.benmanes.caffeine.cache.simulator.admission.Admittor;
@@ -56,6 +58,7 @@ public final class S4WindowTinyLfuPolicy implements KeyOnlyPolicy {
 
   private int sizeWindow;
 
+  @SuppressWarnings("Varifier")
   public S4WindowTinyLfuPolicy(double percentMain, S4WindowTinyLfuSettings settings) {
     this.policyStats = new PolicyStats(name() + " (%.0f%%)", 100 * (1.0d - percentMain));
     this.admittor = Admission.TINYLFU.from(settings.config(), policyStats);
@@ -72,7 +75,7 @@ public S4WindowTinyLfuPolicy(double percentMain, S4WindowTinyLfuSettings setting
 
   /** Returns all variations of this policy based on the configuration parameters. */
   public static Set<Policy> policies(Config config) {
-    S4WindowTinyLfuSettings settings = new S4WindowTinyLfuSettings(config);
+    var settings = new S4WindowTinyLfuSettings(config);
     return settings.percentMain().stream()
         .map(percentMain -> new S4WindowTinyLfuPolicy(percentMain, settings))
         .collect(toUnmodifiableSet());
@@ -104,7 +107,7 @@ public void record(long key) {
 
   /** Adds the entry to the admission window, evicting if necessary. */
   private void onMiss(long key) {
-    Node node = new Node(key, Status.WINDOW);
+    var node = new Node(key, Status.WINDOW);
     node.appendToTail(headWindow);
     data.put(key, node);
     sizeWindow++;
@@ -175,7 +178,7 @@ private void evict() {
   public void finished() {
     for (int i = 0; i < levels; i++) {
       int level = i;
-      int count = (int) data.values().stream()
+      long count = data.values().stream()
           .filter(node -> node.status == Status.MAIN)
           .filter(node -> node.level == level)
           .count();
@@ -193,20 +196,21 @@ enum Status {
   static final class Node {
     final long key;
 
-    Status status;
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable Status status;
+
     int level;
 
     /** Creates a new, unlinked node. */
-    public Node(long key, Status status) {
+    public Node(long key, @Nullable Status status) {
       this.status = status;
       this.key = key;
     }
 
     /** Creates a new sentinel node. */
     static Node sentinel(int level) {
-      Node node = new Node(Long.MIN_VALUE, null);
+      var node = new Node(Long.MIN_VALUE, null);
       node.level = level;
       node.prev = node;
       node.next = node;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCachePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCachePolicy.java
index b5c94c7b7b..99b18731ba 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCachePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCachePolicy.java
@@ -31,8 +31,8 @@ public final class TinyCachePolicy implements KeyOnlyPolicy {
   private final TinyCache tinyCache;
 
   public TinyCachePolicy(Config config) {
+    var settings = new BasicSettings(config);
     this.policyStats = new PolicyStats(name());
-    BasicSettings settings = new BasicSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     tinyCache = new TinyCache((int) Math.ceil(maximumSize / 64.0),
         64, settings.randomSeed());
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCacheWithGhostCachePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCacheWithGhostCachePolicy.java
index 099a43b363..4e00eb15d8 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCacheWithGhostCachePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/TinyCacheWithGhostCachePolicy.java
@@ -31,8 +31,8 @@ public final class TinyCacheWithGhostCachePolicy implements KeyOnlyPolicy {
   private final PolicyStats policyStats;
 
   public TinyCacheWithGhostCachePolicy(Config config) {
+    var settings = new BasicSettings(config);
     this.policyStats = new PolicyStats(name());
-    BasicSettings settings = new BasicSettings(config);
     int maximumSize = Math.toIntExact(settings.maximumSize());
     tinyCache = new TinyCacheWithGhostCache((int) Math.ceil(maximumSize / 64.0),
         64, settings.randomSeed());
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/WindowTinyCachePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/WindowTinyCachePolicy.java
index e2496966d8..4dcf451810 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/WindowTinyCachePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/sketch/tinycache/WindowTinyCachePolicy.java
@@ -15,12 +15,15 @@
  */
 package com.github.benmanes.caffeine.cache.simulator.policy.sketch.tinycache;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.admission.tinycache.TinyCache;
 import com.github.benmanes.caffeine.cache.simulator.admission.tinycache.TinyCacheWithGhostCache;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 /**
@@ -28,14 +31,14 @@
  */
 @PolicySpec(name = "sketch.WindowTinyCache")
 public final class WindowTinyCachePolicy implements KeyOnlyPolicy {
-  private final TinyCache window;
-  private final PolicyStats policyStats;
   private final TinyCacheWithGhostCache tinyCache;
+  private final @Nullable TinyCache window;
+  private final PolicyStats policyStats;
 
   public WindowTinyCachePolicy(Config config) {
     policyStats = new PolicyStats(name());
-    BasicSettings settings = new BasicSettings(config);
-    int maxSize = Math.toIntExact(settings.maximumSize());
+    var settings = new BasicSettings(config);
+    @Var int maxSize = Math.toIntExact(settings.maximumSize());
     if (maxSize <= 64) {
       window = null;
     } else {
@@ -52,7 +55,7 @@ public void record(long key) {
       tinyCache.recordItem(key);
       policyStats.recordHit();
     } else {
-      boolean evicted = tinyCache.addItem(key);
+      @Var boolean evicted = tinyCache.addItem(key);
       if (!evicted && (window != null)) {
         evicted = window.addItem(key);
       }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/S3FifoPolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/S3FifoPolicy.java
index 1c80961ba4..cc424dff84 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/S3FifoPolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/S3FifoPolicy.java
@@ -21,6 +21,8 @@
 import java.util.LinkedHashSet;
 import java.util.function.IntConsumer;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.AccessEvent;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy;
@@ -28,6 +30,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -90,7 +93,7 @@ public S3FifoPolicy(Config config) {
 
   @Override
   public void record(AccessEvent event) {
-    Node node;
+    @Var Node node;
     if ((node = dataSmall.get(event.key())) != null) {
       onHit(event, node, change -> sizeSmall += change);
     } else if ((node = dataMain.get(event.key())) != null) {
@@ -172,7 +175,7 @@ private void evict() {
   }
 
   private void evictFromSmall() {
-    boolean evicted = false;
+    @Var boolean evicted = false;
     while (!evicted && !dataSmall.isEmpty()) {
       var victim = sentinelSmall.prev;
       policyStats.recordOperation();
@@ -193,7 +196,7 @@ private void evictFromSmall() {
   }
 
   private void evictFromMain() {
-    boolean evicted = false;
+    @Var boolean evicted = false;
     while (!evicted && !dataMain.isEmpty()) {
       var victim = sentinelMain.prev;
       policyStats.recordOperation();
@@ -238,7 +241,7 @@ public void finished() {
     checkState(actualSize <= maximumSize, "Total: %s > %s", actualSize, maximumSize);
   }
 
-  private void checkLinks(String label, Long2ObjectMap<Node> data, Node sentinel) {
+  private static void checkLinks(String label, Long2ObjectMap<Node> data, Node sentinel) {
     var forwards = new LinkedHashSet<Node>();
     for (var node = sentinel.next; node != sentinel; node = node.next) {
       checkState(node == data.get(node.key), "%s: %s != %s", label, node, data.get(node.key));
@@ -264,8 +267,9 @@ public PolicyStats stats() {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
+    @Nullable Node prev;
+    @Nullable Node next;
+
     int weight;
     int frequency;
 
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TuQueuePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TuQueuePolicy.java
index cb150676ef..cda39edd49 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TuQueuePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TuQueuePolicy.java
@@ -17,6 +17,8 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import com.github.benmanes.caffeine.cache.simulator.BasicSettings;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.KeyOnlyPolicy;
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
@@ -69,7 +71,7 @@ public class TuQueuePolicy implements KeyOnlyPolicy {
 
   @SuppressWarnings("this-escape")
   public TuQueuePolicy(Config config) {
-    TuQueueSettings settings = new TuQueueSettings(config);
+    var settings = new TuQueueSettings(config);
 
     this.headHot = new Node();
     this.headWarm = new Node();
@@ -125,7 +127,7 @@ private void onHit(Node node) {
 
   /** Adds the entry to the cache as HOT, overflowing to the COLD queue, and evicts if necessary. */
   private void onMiss(long key) {
-    Node node = new Node(key);
+    var node = new Node(key);
     node.type = QueueType.HOT;
     node.appendToTail(headHot);
     data.put(key, node);
@@ -172,9 +174,9 @@ enum QueueType {
   static final class Node {
     final long key;
 
-    Node prev;
-    Node next;
-    QueueType type;
+    @Nullable Node prev;
+    @Nullable Node next;
+    @Nullable QueueType type;
 
     Node() {
       this.key = Long.MIN_VALUE;
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TwoQueuePolicy.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TwoQueuePolicy.java
index 8c7d14e605..54e4fc66ab 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TwoQueuePolicy.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/policy/two_queue/TwoQueuePolicy.java
@@ -20,6 +20,7 @@
 import com.github.benmanes.caffeine.cache.simulator.policy.Policy.PolicySpec;
 import com.github.benmanes.caffeine.cache.simulator.policy.PolicyStats;
 import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.Var;
 import com.typesafe.config.Config;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -58,7 +59,7 @@ public final class TwoQueuePolicy implements KeyOnlyPolicy {
   final Node headMain;
 
   public TwoQueuePolicy(Config config) {
-    TwoQueueSettings settings = new TwoQueueSettings(config);
+    var settings = new TwoQueueSettings(config);
 
     this.headIn = new Node();
     this.headOut = new Node();
@@ -87,7 +88,7 @@ public void record(long key) {
     //   end if
 
     policyStats.recordOperation();
-    Node node = data.get(key);
+    @Var Node node = data.get(key);
     if (node != null) {
       switch (node.type) {
         case MAIN:
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/Metrics.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/Metrics.java
index 24e64fe87b..793b1dfb78 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/Metrics.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/Metrics.java
@@ -115,7 +115,7 @@ public int compare(PolicyStats p1, PolicyStats p2) {
         Object value2 = ((Supplier<?>) metric2.value()).get();
         if (value1 instanceof Comparable<?>) {
           @SuppressWarnings("unchecked")
-          Comparable<Object> comparator = (Comparable<Object>) value1;
+          var comparator = (Comparable<Object>) value1;
           return comparator.compareTo(value2);
         }
         return objectFormatter().apply(value1)
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/TextReporter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/TextReporter.java
index c4c69b3d86..cdbed43159 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/TextReporter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/TextReporter.java
@@ -63,7 +63,7 @@ public void print(List<PolicyStats> results) {
       return;
     }
     try {
-      Path path = Path.of(output);
+      var path = Path.of(output);
       Files.createDirectories(path.getParent());
       Files.write(path, report.getBytes(UTF_8));
     } catch (IOException e) {
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CombinedCsvReport.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CombinedCsvReport.java
index c457b1afcd..425f074bc5 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CombinedCsvReport.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CombinedCsvReport.java
@@ -21,11 +21,13 @@
 
 import java.nio.file.Path;
 import java.text.NumberFormat;
-import java.util.SortedMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeMap;
 import java.util.stream.Stream;
 
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Table;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedMap;
 import com.univocity.parsers.csv.CsvParser;
 import com.univocity.parsers.csv.CsvParserSettings;
 import com.univocity.parsers.csv.CsvWriter;
@@ -38,12 +40,12 @@
  * @author ben.manes@gmail.com (Ben Manes)
  */
 public final class CombinedCsvReport implements Runnable {
-  private final SortedMap<Long, Path> inputFiles;
+  private final ImmutableSortedMap<Long, Path> inputFiles;
   private final Path outputFile;
   private final String metric;
 
-  public CombinedCsvReport(SortedMap<Long, Path> inputFiles, String metric, Path outputFile) {
-    this.inputFiles = requireNonNull(inputFiles);
+  public CombinedCsvReport(ImmutableMap<Long, Path> inputFiles, String metric, Path outputFile) {
+    this.inputFiles = ImmutableSortedMap.copyOf(inputFiles);
     this.outputFile = requireNonNull(outputFile);
     this.metric = metric.replace('_', ' ');
   }
@@ -53,20 +55,21 @@ public void run() {
     writeReport(tabulate());
   }
 
-  /** Returns the combined results for the policy, maximum size, and the metric being compared. */
-  private Table</* policy */ String, /* size */ Long, /* metric */ String> tabulate() {
-    Table<String, Long, String> results = HashBasedTable.create();
+  /** Returns the results for the (policy, maximumSize) to the metric value being compared. */
+  private Map<Label, String> tabulate() {
+    var results = new TreeMap<Label, String>();
     inputFiles.forEach((maximumSize, path) -> {
       var records = newCsvParser().parseAllRecords(path.toFile());
       for (var record : records) {
-        results.put(record.getString("Policy"), maximumSize, record.getValue(metric, ""));
+        var label = new Label(record.getString("Policy"), maximumSize);
+        results.put(label, record.getValue(metric, ""));
       }
     });
     return results;
   }
 
   /** Writes a combined report with the headers: policy, maximumSize, and the metric. */
-  private void writeReport(Table<String, Long, String> table) {
+  private void writeReport(Map<Label, String> table) {
     var policies = newCsvParser()
         .parseAllRecords(inputFiles.values().iterator().next().toFile()).stream()
         .map(record -> record.getString("Policy"))
@@ -79,14 +82,14 @@ private void writeReport(Table<String, Long, String> table) {
     for (var policy : policies) {
       writer.addValue("Policy", policy);
       for (Long size : inputFiles.keySet()) {
-        writer.addValue(formatter.format(size), table.get(policy, size));
+        writer.addValue(formatter.format(size), table.get(new Label(policy, size)));
       }
       writer.writeValuesToRow();
     }
     writer.close();
   }
 
-  private CsvParser newCsvParser() {
+  private static CsvParser newCsvParser() {
     var settings = new CsvParserSettings();
     settings.setHeaderExtractionEnabled(true);
     return new CsvParser(settings);
@@ -98,4 +101,27 @@ private CsvWriter newWriter(String[] headers) {
     settings.setHeaders(headers);
     return new CsvWriter(outputFile.toFile(), settings);
   }
+
+  private static final class Label implements Comparable<Label> {
+    final String policy;
+    final long size;
+
+    Label(String policy, long size) {
+      this.policy = requireNonNull(policy);
+      this.size = size;
+    }
+    @Override
+    public boolean equals(Object o) {
+      return (o instanceof Label) && (compareTo((Label) o) == 0);
+    }
+    @Override
+    public int hashCode() {
+      return Objects.hash(policy, size);
+    }
+    @Override
+    public int compareTo(Label label) {
+      int ordering = policy.compareTo(label.policy);
+      return (ordering == 0) ? Long.compare(size, label.size) : ordering;
+    }
+  }
 }
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CsvReporter.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CsvReporter.java
index daca9ffa0c..488b869b53 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CsvReporter.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/CsvReporter.java
@@ -45,8 +45,8 @@ public CsvReporter(Config config, Set<Characteristic> characteristics) {
 
   @Override
   protected String assemble(Set<String> headers, List<PolicyStats> results) {
-    StringWriter output = new StringWriter();
-    CsvWriter writer = new CsvWriter(output, new CsvWriterSettings());
+    var output = new StringWriter();
+    var writer = new CsvWriter(output, new CsvWriterSettings());
     writer.writeHeaders(headers);
     for (PolicyStats policyStats : results) {
       String[] data = headers.stream()
diff --git a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/PlotCsv.java b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/PlotCsv.java
index 890aa63679..b31e69c207 100644
--- a/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/PlotCsv.java
+++ b/simulator/src/main/java/com/github/benmanes/caffeine/cache/simulator/report/csv/PlotCsv.java
@@ -46,6 +46,7 @@
 import com.google.auto.value.AutoValue;
 import com.google.auto.value.AutoValue.CopyAnnotations;
 import com.google.common.base.Strings;
+import com.google.errorprone.annotations.Var;
 import com.univocity.parsers.csv.CsvParser;
 import com.univocity.parsers.csv.CsvParserSettings;
 
@@ -118,9 +119,9 @@ private void configurePlot(JFreeChart chart) {
     }
   }
 
-  private Range calculateRange(CategoryPlot plot) {
-    double upperBound = 0;
-    double lowerBound = 100;
+  private static Range calculateRange(CategoryPlot plot) {
+    @Var double upperBound = 0;
+    @Var double lowerBound = 100;
     for (int series = 0; series < plot.getDataset().getRowCount(); series++) {
       for (int item = 0; item < plot.getDataset().getColumnCount(); item++) {
         var value = plot.getDataset().getValue(series, item);
@@ -186,17 +187,16 @@ private void configureAxis(Axis axis) {
   }
 
   private Color[] getWheelColors() {
-    int n = 360;
-    int wheelStep = 3;
-    int paintIndex = 0;
-    var colors = new Color[n];
-    var wheelPaints = new boolean[n];
-    while (paintIndex < n) {
-      int step = n / wheelStep;
-      for (int angle = 0; angle < n; angle += step) {
+    @Var int wheelStep = 3;
+    @Var int paintIndex = 0;
+    var colors = new Color[360];
+    var wheelPaints = new boolean[colors.length];
+    while (paintIndex < colors.length) {
+      int step = (colors.length / wheelStep);
+      for (int angle = 0; angle < colors.length; angle += step) {
         if (!wheelPaints[angle]) {
           wheelPaints[angle] = true;
-          float hue = ((float) angle) / n;
+          float hue = ((float) angle) / colors.length;
           colors[paintIndex++] = getLineColor(hue);
         }
       }
diff --git a/simulator/src/test/java/com/github/benmanes/caffeine/cache/simulator/admission/bloom/MembershipTest.java b/simulator/src/test/java/com/github/benmanes/caffeine/cache/simulator/admission/bloom/MembershipTest.java
index 7146a9bcb3..32ba34362e 100644
--- a/simulator/src/test/java/com/github/benmanes/caffeine/cache/simulator/admission/bloom/MembershipTest.java
+++ b/simulator/src/test/java/com/github/benmanes/caffeine/cache/simulator/admission/bloom/MembershipTest.java
@@ -32,16 +32,18 @@
 import com.github.benmanes.caffeine.cache.simulator.membership.FilterType;
 import com.github.benmanes.caffeine.cache.simulator.membership.Membership;
 import com.github.benmanes.caffeine.cache.simulator.membership.bloom.BloomFilter;
-import com.google.common.collect.ImmutableList;
 import com.jakewharton.fliptables.FlipTable;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntList;
+
 /**
  * @author ashish0x90 (Ashish Yadav)
  * @author ben.manes@gmail.com (Ben Manes)
  */
-public class MembershipTest {
+public final class MembershipTest {
   static final String[] HEADERS = { "Type", "Capacity", "Insertions", "False Positives" };
   static final double EXPECTED_INSERTIONS_MULTIPLIER = 0.5;
   static final double FPP = 0.03;
@@ -50,7 +52,7 @@ public class MembershipTest {
 
   @Test(dataProvider = "filterTypes")
   public void bloomFilterTest(FilterType filterType) {
-    List<Integer> capacities = new ArrayList<>(ImmutableList.of(0, 1));
+    var capacities = new IntArrayList(IntList.of(0, 1));
     for (int capacity = 2 << 10; capacity < (2 << 22); capacity <<= 2) {
       capacities.add(capacity);
     }
@@ -59,7 +61,7 @@ public void bloomFilterTest(FilterType filterType) {
     for (int capacity : capacities) {
       long[] input = random.longs(capacity).distinct().toArray();
       Config config = getConfig(filterType, capacity);
-      List<String[]> rows = new ArrayList<>();
+      var rows = new ArrayList<String[]>();
 
       Membership filter = filterType.create(config);
       int falsePositives = falsePositives(filter, input);
@@ -79,7 +81,7 @@ public void bloomFilterTest(FilterType filterType) {
 
   @Test(dataProvider = "ensureCapacity")
   public void caffeine_ensureCapacity(int expectedInsertions, double fpp) {
-    BloomFilter filter = new BloomFilter();
+    var filter = new BloomFilter();
     filter.ensureCapacity(expectedInsertions, fpp);
     assertThat(filter.put(-1)).isTrue();
   }
@@ -119,7 +121,7 @@ private int falsePositives(Membership filter, long[] input) {
   }
 
   private Config getConfig(FilterType filterType, int capacity) {
-    Map<String, Object> properties = Map.of(
+    var properties = Map.of(
         "membership.expected-insertions-multiplier", EXPECTED_INSERTIONS_MULTIPLIER,
         "membership.filter", filterType.name(),
         "maximum-size", capacity,
@@ -141,7 +143,7 @@ private static String[] row(FilterType filterType, int capacity,
 
   /** Displays the rows as a pretty printed table. */
   private static void printTable(List<String[]> rows) {
-    String[][] data = new String[rows.size()][HEADERS.length];
+    var data = new String[rows.size()][HEADERS.length];
     for (int i = 0; i < rows.size(); i++) {
       data[i] = rows.get(i);
     }