diff --git a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
index ed65114..384de36 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
@@ -246,7 +246,7 @@
       }
 
       // Resolve all global imports.
-      Set<CodeOwnerConfigImport> globalImports = getGlobalImports(0, codeOwnerConfig);
+      ImmutableSet<CodeOwnerConfigImport> globalImports = getGlobalImports(0, codeOwnerConfig);
       OptionalResultWithMessages<List<UnresolvedImport>> unresolvedGlobalImports =
           resolveImports(codeOwnerConfig.key(), globalImports, resolvedCodeOwnerConfigBuilder);
       messages.addAll(unresolvedGlobalImports.messages());
@@ -292,7 +292,7 @@
       }
 
       // Resolve per-file imports.
-      Set<CodeOwnerConfigImport> perFileImports =
+      ImmutableSet<CodeOwnerConfigImport> perFileImports =
           getPerFileImports(
               0, codeOwnerConfig.key(), resolvedCodeOwnerConfigBuilder.codeOwnerSets());
       OptionalResultWithMessages<List<UnresolvedImport>> unresolvedPerFileImports =
@@ -499,7 +499,7 @@
         !message.isEmpty() ? ImmutableList.of(message) : ImmutableList.of());
   }
 
-  private Set<CodeOwnerConfigImport> getGlobalImports(
+  private ImmutableSet<CodeOwnerConfigImport> getGlobalImports(
       int importLevel, CodeOwnerConfig codeOwnerConfig) {
     return codeOwnerConfig.imports().stream()
         .map(
@@ -509,11 +509,11 @@
         .collect(toImmutableSet());
   }
 
-  private Set<CodeOwnerConfigImport> getPerFileImports(
+  private ImmutableSet<CodeOwnerConfigImport> getPerFileImports(
       int importLevel,
       CodeOwnerConfig.Key importingCodeOwnerConfig,
       Set<CodeOwnerSet> codeOwnerSets) {
-    Set<CodeOwnerConfigImport> codeOwnerConfigImports = new HashSet<>();
+    ImmutableSet.Builder<CodeOwnerConfigImport> codeOwnerConfigImports = ImmutableSet.builder();
     for (CodeOwnerSet codeOwnerSet : codeOwnerSets) {
       codeOwnerSet.imports().stream()
           .forEach(
@@ -525,7 +525,7 @@
                           codeOwnerConfigReference,
                           codeOwnerSet)));
     }
-    return codeOwnerConfigImports;
+    return codeOwnerConfigImports.build();
   }
 
   public static CodeOwnerConfig.Key createKeyForImportedCodeOwnerConfig(
