diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListTemplates.java
index a7aaf0c316..12e699400a 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListTemplates.java
@@ -41,37 +41,6 @@ ImmutableList.Builder<T> after() {
     }
   }
 
-  /** Prefer {@link ImmutableList#of()} over more contrived alternatives. */
-  static final class EmptyImmutableList<T> {
-    @BeforeTemplate
-    ImmutableList<T> before() {
-      return Refaster.anyOf(
-          ImmutableList.<T>builder().build(), Stream.<T>empty().collect(toImmutableList()));
-    }
-
-    @AfterTemplate
-    ImmutableList<T> after() {
-      return ImmutableList.of();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableList#of(Object)} over alternatives that don't communicate the
-   * immutability of the resulting list at the type level.
-   */
-  // XXX: Note that this rewrite rule is incorrect for nullable elements.
-  static final class SingletonImmutableList<T> {
-    @BeforeTemplate
-    List<T> before(T element) {
-      return Collections.singletonList(element);
-    }
-
-    @AfterTemplate
-    ImmutableList<T> after(T element) {
-      return ImmutableList.of(element);
-    }
-  }
-
   /**
    * Prefer {@link ImmutableList#copyOf(Iterable)} and variants over more contrived alternatives.
    */
@@ -186,4 +155,117 @@ ImmutableList<T> after(Stream<T> stream) {
       return stream.collect(toImmutableSet()).asList();
     }
   }
+
+  /**
+   * Prefer {@link ImmutableList#of()} over more contrived alternatives or alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
+  // this and similar Refaster templates are replaced with an Error Prone check.
+  static final class ImmutableListOf<T> {
+    @BeforeTemplate
+    List<T> before() {
+      return Refaster.anyOf(
+          ImmutableList.<T>builder().build(),
+          Stream.<T>empty().collect(toImmutableList()),
+          Collections.emptyList(),
+          List.of());
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after() {
+      return ImmutableList.of();
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object)} over more contrived alternatives or alternatives that
+   * don't communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Note that the replacement of `Collections#singletonList` is incorrect for nullable
+  // elements.
+  static final class ImmutableListOf1<T> {
+    @BeforeTemplate
+    List<T> before(T e1) {
+      return Refaster.anyOf(
+          ImmutableList.<T>builder().add(e1).build(), Collections.singletonList(e1), List.of(e1));
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1) {
+      return ImmutableList.of(e1);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object)} over alternatives that don't communicate the
+   * immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf2<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2) {
+      return List.of(e1, e2);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2) {
+      return ImmutableList.of(e1, e2);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf3<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3) {
+      return List.of(e1, e2, e3);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3) {
+      return ImmutableList.of(e1, e2, e3);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf4<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3, T e4) {
+      return List.of(e1, e2, e3, e4);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3, T e4) {
+      return ImmutableList.of(e1, e2, e3, e4);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableList#of(Object, Object, Object, Object, Object)} over alternatives that
+   * don't communicate the immutability of the resulting list at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableList.builder()` usages.
+  static final class ImmutableListOf5<T> {
+    @BeforeTemplate
+    List<T> before(T e1, T e2, T e3, T e4, T e5) {
+      return List.of(e1, e2, e3, e4, e5);
+    }
+
+    @AfterTemplate
+    ImmutableList<T> after(T e1, T e2, T e3, T e4, T e5) {
+      return ImmutableList.of(e1, e2, e3, e4, e5);
+    }
+  }
 }
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java
index 5c8aa28142..1ed11f0339 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java
@@ -40,41 +40,6 @@ ImmutableMap.Builder<K, V> after() {
     }
   }
 
-  /** Prefer {@link ImmutableMap#of()} over more contrived alternatives. */
-  static final class EmptyImmutableMap<K, V> {
-    @BeforeTemplate
-    ImmutableMap<K, V> before() {
-      return ImmutableMap.<K, V>builder().build();
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after() {
-      return ImmutableMap.of();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives and
-   * alternatives that don't communicate the immutability of the resulting map at the type level.
-   */
-  // XXX: One can define variants for more than one key-value pair, but at some point the builder
-  // actually produces nicer code. So it's not clear we should add Refaster templates for those
-  // variants.
-  // XXX: Note that the `singletonMap` rewrite rule is incorrect for nullable elements.
-  static final class PairToImmutableMap<K, V> {
-    @BeforeTemplate
-    Map<K, V> before(K key, V value) {
-      return Refaster.anyOf(
-          ImmutableMap.<K, V>builder().put(key, value).build(),
-          Collections.singletonMap(key, value));
-    }
-
-    @AfterTemplate
-    ImmutableMap<K, V> after(K key, V value) {
-      return ImmutableMap.of(key, value);
-    }
-  }
-
   /** Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives. */
   static final class EntryToImmutableMap<K, V> {
     @BeforeTemplate
@@ -242,6 +207,113 @@ ImmutableMap<K, V2> after(Map<K, V1> map) {
     }
   }
 
+  /**
+   * Prefer {@link ImmutableMap#of()} over more contrived alternatives or alternatives that don't
+   * communicate the immutability of the resulting map at the type level.
+   */
+  static final class ImmutableMapOf<K, V> {
+    @BeforeTemplate
+    Map<K, V> before() {
+      return Refaster.anyOf(ImmutableMap.<K, V>builder().build(), Collections.emptyMap(), Map.of());
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after() {
+      return ImmutableMap.of();
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives or alternatives
+   * that don't communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Note that the replacement of `Collections#singletonMap` is incorrect for nullable
+  // elements.
+  static final class ImmutableMapOf1<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1) {
+      return Refaster.anyOf(
+          ImmutableMap.<K, V>builder().put(k1, v1).build(),
+          Collections.singletonMap(k1, v1),
+          Map.of(k1, v1));
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1) {
+      return ImmutableMap.of(k1, v1);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf2<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2) {
+      return Map.of(k1, v1, k2, v2);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2) {
+      return ImmutableMap.of(k1, v1, k2, v2);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object)} over
+   * alternatives that don't communicate the immutability of the resulting map at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf3<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3) {
+      return Map.of(k1, v1, k2, v2, k3, v3);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object, Object, Object)}
+   * over alternatives that don't communicate the immutability of the resulting map at the type
+   * level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf4<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object, Object, Object,
+   * Object, Object)} over alternatives that don't communicate the immutability of the resulting map
+   * at the type level.
+   */
+  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  static final class ImmutableMapOf5<K, V> {
+    @BeforeTemplate
+    Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+      return Map.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+      return ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+    }
+  }
+
   // XXX: Add a template for this:
   // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf)
   // ->
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java
index 7e19377eaa..510f34f9f2 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java
@@ -39,37 +39,6 @@ ImmutableSet.Builder<T> after() {
     }
   }
 
-  /** Prefer {@link ImmutableSet#of()} over more contrived alternatives. */
-  static final class EmptyImmutableSet<T> {
-    @BeforeTemplate
-    ImmutableSet<T> before() {
-      return Refaster.anyOf(
-          ImmutableSet.<T>builder().build(), Stream.<T>empty().collect(toImmutableSet()));
-    }
-
-    @AfterTemplate
-    ImmutableSet<T> after() {
-      return ImmutableSet.of();
-    }
-  }
-
-  /**
-   * Prefer {@link ImmutableSet#of(Object)} over alternatives that don't communicate the
-   * immutability of the resulting set at the type level.
-   */
-  // XXX: Note that this rewrite rule is incorrect for nullable elements.
-  static final class SingletonImmutableSet<T> {
-    @BeforeTemplate
-    Set<T> before(T element) {
-      return Collections.singleton(element);
-    }
-
-    @AfterTemplate
-    ImmutableSet<T> after(T element) {
-      return ImmutableSet.of(element);
-    }
-  }
-
   /** Prefer {@link ImmutableSet#copyOf(Iterable)} and variants over more contrived alternatives. */
   static final class IterableToImmutableSet<T> {
     @BeforeTemplate
@@ -138,4 +107,116 @@ ImmutableSet<T> after(SetView<T> set) {
       return set.immutableCopy();
     }
   }
+
+  /**
+   * Prefer {@link ImmutableSet#of()} over more contrived alternatives or alternatives that don't
+   * communicate the immutability of the resulting set at the type level.
+   */
+  // XXX: The `Stream` variant may be too contrived to warrant inclusion. Review its usage if/when
+  // this and similar Refaster templates are replaced with an Error Prone check.
+  static final class ImmutableSetOf<T> {
+    @BeforeTemplate
+    Set<T> before() {
+      return Refaster.anyOf(
+          ImmutableSet.<T>builder().build(),
+          Stream.<T>empty().collect(toImmutableSet()),
+          Collections.emptySet(),
+          Set.of());
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after() {
+      return ImmutableSet.of();
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableSet#of(Object)} over more contrived alternatives or alternatives that
+   * don't communicate the immutability of the resulting set at the type level.
+   */
+  // XXX: Note that the replacement of `Collections#singleton` is incorrect for nullable elements.
+  static final class ImmutableSetOf1<T> {
+    @BeforeTemplate
+    Set<T> before(T e1) {
+      return Refaster.anyOf(
+          ImmutableSet.<T>builder().add(e1).build(), Collections.singleton(e1), Set.of(e1));
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1) {
+      return ImmutableSet.of(e1);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableSet#of(Object, Object)} over alternatives that don't communicate the
+   * immutability of the resulting set at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableSet.builder()` usages.
+  static final class ImmutableSetOf2<T> {
+    @BeforeTemplate
+    Set<T> before(T e1, T e2) {
+      return Set.of(e1, e2);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1, T e2) {
+      return ImmutableSet.of(e1, e2);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableSet#of(Object, Object, Object)} over alternatives that don't communicate
+   * the immutability of the resulting set at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableSet.builder()` usages.
+  static final class ImmutableSetOf3<T> {
+    @BeforeTemplate
+    Set<T> before(T e1, T e2, T e3) {
+      return Set.of(e1, e2, e3);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1, T e2, T e3) {
+      return ImmutableSet.of(e1, e2, e3);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableSet#of(Object, Object, Object, Object)} over alternatives that don't
+   * communicate the immutability of the resulting set at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableSet.builder()` usages.
+  static final class ImmutableSetOf4<T> {
+    @BeforeTemplate
+    Set<T> before(T e1, T e2, T e3, T e4) {
+      return Set.of(e1, e2, e3, e4);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1, T e2, T e3, T e4) {
+      return ImmutableSet.of(e1, e2, e3, e4);
+    }
+  }
+
+  /**
+   * Prefer {@link ImmutableSet#of(Object, Object, Object, Object, Object)} over alternatives that
+   * don't communicate the immutability of the resulting set at the type level.
+   */
+  // XXX: Consider writing an Error Prone check which also flags straightforward
+  // `ImmutableSet.builder()` usages.
+  static final class ImmutableSetOf5<T> {
+    @BeforeTemplate
+    Set<T> before(T e1, T e2, T e3, T e4, T e5) {
+      return Set.of(e1, e2, e3, e4, e5);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T e1, T e2, T e3, T e4, T e5) {
+      return ImmutableSet.of(e1, e2, e3, e4, e5);
+    }
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java
index f2d564e343..2034c5bfb7 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java
@@ -31,16 +31,6 @@ ImmutableList.Builder<String> testImmutableListBuilder() {
     return new ImmutableList.Builder<>();
   }
 
-  ImmutableSet<ImmutableList<Integer>> testEmptyImmutableList() {
-    return ImmutableSet.of(
-        ImmutableList.<Integer>builder().build(),
-        Stream.<Integer>empty().collect(toImmutableList()));
-  }
-
-  List<String> testSingletonImmutableList() {
-    return Collections.singletonList("foo");
-  }
-
   ImmutableSet<ImmutableList<Integer>> testIterableToImmutableList() {
     return ImmutableSet.of(
         ImmutableList.of(1).stream().collect(toImmutableList()),
@@ -79,4 +69,32 @@ ImmutableSet<ImmutableList<String>> testImmutableListSortedCopyOfWithCustomCompa
   ImmutableList<Integer> testStreamToDistinctImmutableList() {
     return Stream.of(1).distinct().collect(toImmutableList());
   }
+
+  ImmutableSet<List<Integer>> testImmutableListOf() {
+    return ImmutableSet.of(
+        ImmutableList.<Integer>builder().build(),
+        Stream.<Integer>empty().collect(toImmutableList()),
+        Collections.<Integer>emptyList(),
+        List.<Integer>of());
+  }
+
+  ImmutableSet<List<Integer>> testImmutableListOf1() {
+    return ImmutableSet.of(Collections.singletonList(1), List.of(1));
+  }
+
+  List<Integer> testImmutableListOf2() {
+    return List.of(1, 2);
+  }
+
+  List<Integer> testImmutableListOf3() {
+    return List.of(1, 2, 3);
+  }
+
+  List<Integer> testImmutableListOf4() {
+    return List.of(1, 2, 3, 4);
+  }
+
+  List<Integer> testImmutableListOf5() {
+    return List.of(1, 2, 3, 4, 5);
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java
index f13829aad0..edab2e982c 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java
@@ -32,14 +32,6 @@ ImmutableList.Builder<String> testImmutableListBuilder() {
     return ImmutableList.builder();
   }
 
-  ImmutableSet<ImmutableList<Integer>> testEmptyImmutableList() {
-    return ImmutableSet.of(ImmutableList.of(), ImmutableList.of());
-  }
-
-  List<String> testSingletonImmutableList() {
-    return ImmutableList.of("foo");
-  }
-
   ImmutableSet<ImmutableList<Integer>> testIterableToImmutableList() {
     return ImmutableSet.of(
         ImmutableList.copyOf(ImmutableList.of(1)),
@@ -74,4 +66,29 @@ ImmutableSet<ImmutableList<String>> testImmutableListSortedCopyOfWithCustomCompa
   ImmutableList<Integer> testStreamToDistinctImmutableList() {
     return Stream.of(1).collect(toImmutableSet()).asList();
   }
+
+  ImmutableSet<List<Integer>> testImmutableListOf() {
+    return ImmutableSet.of(
+        ImmutableList.of(), ImmutableList.of(), ImmutableList.of(), ImmutableList.of());
+  }
+
+  ImmutableSet<List<Integer>> testImmutableListOf1() {
+    return ImmutableSet.of(ImmutableList.of(1), ImmutableList.of(1));
+  }
+
+  List<Integer> testImmutableListOf2() {
+    return ImmutableList.of(1, 2);
+  }
+
+  List<Integer> testImmutableListOf3() {
+    return ImmutableList.of(1, 2, 3);
+  }
+
+  List<Integer> testImmutableListOf4() {
+    return ImmutableList.of(1, 2, 3, 4);
+  }
+
+  List<Integer> testImmutableListOf5() {
+    return ImmutableList.of(1, 2, 3, 4, 5);
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java
index d119cd9763..5678b0d9e2 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java
@@ -23,16 +23,6 @@ ImmutableMap.Builder<String, Integer> testImmutableMapBuilder() {
     return new ImmutableMap.Builder<>();
   }
 
-  ImmutableMap<String, Integer> testEmptyImmutableMap() {
-    return ImmutableMap.<String, Integer>builder().build();
-  }
-
-  ImmutableSet<Map<String, Integer>> testPairToImmutableMap() {
-    return ImmutableSet.of(
-        ImmutableMap.<String, Integer>builder().put("foo", 1).build(),
-        Collections.singletonMap("bar", 2));
-  }
-
   ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
     return ImmutableSet.of(
         ImmutableMap.<String, Integer>builder().put(Map.entry("foo", 1)).build(),
@@ -86,4 +76,34 @@ ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap
             ImmutableMap.of("bar", 2L).keySet(),
             k -> Math.toIntExact(ImmutableMap.of("bar", 2L).get(k))));
   }
+
+  ImmutableSet<Map<String, String>> testImmutableMapOf() {
+    return ImmutableSet.of(
+        ImmutableMap.<String, String>builder().build(),
+        Collections.<String, String>emptyMap(),
+        Map.<String, String>of());
+  }
+
+  ImmutableSet<Map<String, String>> testImmutableMapOf1() {
+    return ImmutableSet.of(
+        ImmutableMap.<String, String>builder().put("k1", "v1").build(),
+        Collections.singletonMap("k1", "v1"),
+        Map.of("k1", "v1"));
+  }
+
+  Map<String, String> testImmutableMapOf2() {
+    return Map.of("k1", "v1", "k2", "v2");
+  }
+
+  Map<String, String> testImmutableMapOf3() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3");
+  }
+
+  Map<String, String> testImmutableMapOf4() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4");
+  }
+
+  Map<String, String> testImmutableMapOf5() {
+    return Map.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5");
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java
index e1638de70e..37f84c3da0 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java
@@ -23,14 +23,6 @@ ImmutableMap.Builder<String, Integer> testImmutableMapBuilder() {
     return ImmutableMap.builder();
   }
 
-  ImmutableMap<String, Integer> testEmptyImmutableMap() {
-    return ImmutableMap.of();
-  }
-
-  ImmutableSet<Map<String, Integer>> testPairToImmutableMap() {
-    return ImmutableSet.of(ImmutableMap.of("foo", 1), ImmutableMap.of("bar", 2));
-  }
-
   ImmutableSet<ImmutableMap<String, Integer>> testEntryToImmutableMap() {
     return ImmutableSet.of(
         ImmutableMap.of(Map.entry("foo", 1).getKey(), Map.entry("foo", 1).getValue()),
@@ -72,4 +64,29 @@ ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap
         ImmutableMap.copyOf(
             Maps.transformValues(ImmutableMap.of("bar", 2L), v -> Math.toIntExact(v))));
   }
+
+  ImmutableSet<Map<String, String>> testImmutableMapOf() {
+    return ImmutableSet.of(ImmutableMap.of(), ImmutableMap.of(), ImmutableMap.of());
+  }
+
+  ImmutableSet<Map<String, String>> testImmutableMapOf1() {
+    return ImmutableSet.of(
+        ImmutableMap.of("k1", "v1"), ImmutableMap.of("k1", "v1"), ImmutableMap.of("k1", "v1"));
+  }
+
+  Map<String, String> testImmutableMapOf2() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2");
+  }
+
+  Map<String, String> testImmutableMapOf3() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3");
+  }
+
+  Map<String, String> testImmutableMapOf4() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4");
+  }
+
+  Map<String, String> testImmutableMapOf5() {
+    return ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3", "k4", "v4", "k5", "v5");
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java
index 4fd3650179..65dcdfa9f1 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java
@@ -30,15 +30,6 @@ ImmutableSet.Builder<String> testImmutableSetBuilder() {
     return new ImmutableSet.Builder<>();
   }
 
-  ImmutableSet<ImmutableSet<Integer>> testEmptyImmutableSet() {
-    return ImmutableSet.of(
-        ImmutableSet.<Integer>builder().build(), Stream.<Integer>empty().collect(toImmutableSet()));
-  }
-
-  Set<String> testSingletonImmutableSet() {
-    return Collections.singleton("foo");
-  }
-
   ImmutableSet<ImmutableSet<Integer>> testIterableToImmutableSet() {
     return ImmutableSet.of(
         ImmutableList.of(1).stream().collect(toImmutableSet()),
@@ -62,4 +53,33 @@ ImmutableSet<ImmutableSet<Integer>> testStreamToImmutableSet() {
   ImmutableSet<Integer> testImmutableSetCopyOfSetView() {
     return ImmutableSet.copyOf(Sets.difference(ImmutableSet.of(1), ImmutableSet.of(2)));
   }
+
+  ImmutableSet<Set<Integer>> testImmutableSetOf() {
+    return ImmutableSet.of(
+        ImmutableSet.<Integer>builder().build(),
+        Stream.<Integer>empty().collect(toImmutableSet()),
+        Collections.<Integer>emptySet(),
+        Set.<Integer>of());
+  }
+
+  ImmutableSet<Set<Integer>> testImmutableSetOf1() {
+    return ImmutableSet.of(
+        ImmutableSet.<Integer>builder().add(1).build(), Collections.singleton(1), Set.of(1));
+  }
+
+  Set<Integer> testImmutableSetOf2() {
+    return Set.of(1, 2);
+  }
+
+  Set<Integer> testImmutableSetOf3() {
+    return Set.of(1, 2, 3);
+  }
+
+  Set<Integer> testImmutableSetOf4() {
+    return Set.of(1, 2, 3, 4);
+  }
+
+  Set<Integer> testImmutableSetOf5() {
+    return Set.of(1, 2, 3, 4, 5);
+  }
 }
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java
index b23aac8871..421e6c29ba 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java
@@ -30,14 +30,6 @@ ImmutableSet.Builder<String> testImmutableSetBuilder() {
     return ImmutableSet.builder();
   }
 
-  ImmutableSet<ImmutableSet<Integer>> testEmptyImmutableSet() {
-    return ImmutableSet.of(ImmutableSet.of(), ImmutableSet.of());
-  }
-
-  Set<String> testSingletonImmutableSet() {
-    return ImmutableSet.of("foo");
-  }
-
   ImmutableSet<ImmutableSet<Integer>> testIterableToImmutableSet() {
     return ImmutableSet.of(
         ImmutableSet.copyOf(ImmutableList.of(1)),
@@ -61,4 +53,29 @@ ImmutableSet<ImmutableSet<Integer>> testStreamToImmutableSet() {
   ImmutableSet<Integer> testImmutableSetCopyOfSetView() {
     return Sets.difference(ImmutableSet.of(1), ImmutableSet.of(2)).immutableCopy();
   }
+
+  ImmutableSet<Set<Integer>> testImmutableSetOf() {
+    return ImmutableSet.of(
+        ImmutableSet.of(), ImmutableSet.of(), ImmutableSet.of(), ImmutableSet.of());
+  }
+
+  ImmutableSet<Set<Integer>> testImmutableSetOf1() {
+    return ImmutableSet.of(ImmutableSet.of(1), ImmutableSet.of(1), ImmutableSet.of(1));
+  }
+
+  Set<Integer> testImmutableSetOf2() {
+    return ImmutableSet.of(1, 2);
+  }
+
+  Set<Integer> testImmutableSetOf3() {
+    return ImmutableSet.of(1, 2, 3);
+  }
+
+  Set<Integer> testImmutableSetOf4() {
+    return ImmutableSet.of(1, 2, 3, 4);
+  }
+
+  Set<Integer> testImmutableSetOf5() {
+    return ImmutableSet.of(1, 2, 3, 4, 5);
+  }
 }