Make ImplicitErrorIndex immutable and deterministic

Author: adwsingh

framework-errors/src/main/java/software/amazon/smithy/framework/knowledge/ImplicitErrorIndex.java

@@ -5,10 +5,11 @@
 
 package software.amazon.smithy.framework.knowledge;
 
+import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeSet;
 import software.amazon.smithy.framework.traits.ImplicitErrorsTrait;
 import software.amazon.smithy.model.Model;
 import software.amazon.smithy.model.knowledge.KnowledgeIndex;
@@ -21,10 +22,13 @@
  */
 public final class ImplicitErrorIndex implements KnowledgeIndex {
 
-    private final Map<ShapeId, Set<ShapeId>> serviceImplicitErrorMap = new HashMap<>();
-    private final Set<ShapeId> implicitErrors = new HashSet<>();
+    private final Map<ShapeId, Set<ShapeId>> serviceImplicitErrorMap;
+    private final Set<ShapeId> implicitErrors;
 
     private ImplicitErrorIndex(Model model) {
+        var serviceImplicitError = new HashMap<ShapeId, Set<ShapeId>>();
+        var allImplicitErrors = new TreeSet<ShapeId>();
+
         for (var service : model.getServiceShapes()) {
             for (var traitEntry : service.getAllTraits().entrySet()) {
                 var traitShapeOptional = model.getShape(traitEntry.getKey());
@@ -33,25 +37,33 @@ private ImplicitErrorIndex(Model model) {
                     // has --allow-unknown-traits set to true.
                     continue;
                 }
+
                 var traitShape = traitShapeOptional.get();
                 if (traitShape.hasTrait(ImplicitErrorsTrait.class)) {
                     var implicitErrorsTrait = traitShape.expectTrait(ImplicitErrorsTrait.class);
-                    var implicitErrorList = serviceImplicitErrorMap.computeIfAbsent(
+                    var implicitErrorList = serviceImplicitError.computeIfAbsent(
                             service.toShapeId(),
-                            k -> new HashSet<>());
+                            k -> new TreeSet<>());
                     implicitErrorList.addAll(implicitErrorsTrait.getValues());
-                    implicitErrors.addAll(implicitErrorsTrait.getValues());
+                    allImplicitErrors.addAll(implicitErrorsTrait.getValues());
                 }
             }
         }
+
+        var immutableServiceMap = new HashMap<ShapeId, Set<ShapeId>>();
+        for (var entry : serviceImplicitError.entrySet()) {
+            immutableServiceMap.put(entry.getKey(), Collections.unmodifiableSet(entry.getValue()));
+        }
+        this.serviceImplicitErrorMap = Collections.unmodifiableMap(immutableServiceMap);
+        this.implicitErrors = Collections.unmodifiableSet(allImplicitErrors);
     }
 
     public static ImplicitErrorIndex of(Model model) {
         return model.getKnowledge(ImplicitErrorIndex.class, ImplicitErrorIndex::new);
     }
 
     public Set<ShapeId> getImplicitErrorsForService(ToShapeId toShapeId) {
-        return serviceImplicitErrorMap.computeIfAbsent(toShapeId.toShapeId(), k -> new HashSet<>());
+        return serviceImplicitErrorMap.getOrDefault(toShapeId.toShapeId(), Collections.emptySet());
     }
 
     public boolean isImplicitError(ShapeId shapeId) {