Fix inconsistent set ordering in annotations

Author: akshat62

Lib/annotationlib.py

@@ -371,11 +371,24 @@ def __convert_to_ast(self, other):
         elif type(other) in (list, tuple, set):
             extra_names = {}
             elts = []
-            for elt in other:
-                new_elt, new_extra_names = self.__convert_to_ast(elt)
-                if new_extra_names is not None:
-                    extra_names.update(new_extra_names)
-                elts.append(new_elt)
+
+            # For sets of types, sort elements by name for consistent ordering.
+            if type(other) is set and all(isinstance(x, type) for x in other):
+                # Sort the elements by name to ensure deterministic output.
+                sorted_elts = sorted(other, key=lambda x: x.__name__)
+                for elt in sorted_elts:
+                    new_elt, new_extra_names = self.__convert_to_ast(elt)
+                    if new_extra_names is not None:
+                        extra_names.update(new_extra_names)
+                    elts.append(new_elt)
+            else:
+                # For lists, tuples, and other sets, preserve the original order.
+                for elt in other:
+                    new_elt, new_extra_names = self.__convert_to_ast(elt)
+                    if new_extra_names is not None:
+                        extra_names.update(new_extra_names)
+                    elts.append(new_elt)
+
             ast_class = {list: ast.List, tuple: ast.Tuple, set: ast.Set}[type(other)]
             return ast_class(elts), extra_names
         else:
@@ -817,6 +830,10 @@ def _stringify_single(anno):
         return anno
     elif isinstance(anno, _Template):
         return ast.unparse(_template_to_ast(anno))
+    elif isinstance(anno, set) and all(isinstance(x, type) for x in anno):
+        # Sort set elements by name to ensure consistent ordering.
+        sorted_elements = sorted(anno, key=lambda x: x.__name__)
+        return "{" + ", ".join(x.__name__ for x in sorted_elements) + "}"
     else:
         return repr(anno)
 
@@ -1022,10 +1039,17 @@ def annotations_to_string(annotations):
 
     Always returns a fresh a dictionary.
     """
-    return {
-        n: t if isinstance(t, str) else type_repr(t)
-        for n, t in annotations.items()
-    }
+    result = {}
+    for n, t in annotations.items():
+        if isinstance(t, str):
+            result[n] = t
+        elif isinstance(t, set) and all(isinstance(x, type) for x in t):
+            # Sort set elements by name to ensure consistent ordering.
+            sorted_elements = sorted(t, key=lambda x: x.__name__)
+            result[n] = "{" + ", ".join(x.__name__ for x in sorted_elements) + "}"
+        else:
+            result[n] = type_repr(t)
+    return result
 
 
 def _get_and_call_annotate(obj, format):

Lib/test/test_annotationlib.py

@@ -394,6 +394,17 @@ def g(
             },
         )
 
+    def test_set_ordering_consistency(self):
+        """Test that sets of types are consistently ordered in string representations."""
+        # Test with direct set annotations
+        def g1(x: {int, str}):
+            pass
+
+        anno_g1 = get_annotations(g1, format=Format.STRING)
+
+        # The set should have elements sorted by name (int before str)
+        self.assertEqual(anno_g1["x"], "{int, str}")
+
     def test_nested_expressions(self):
         def f(
             nested: list[Annotated[set[int], "set of ints", 4j]],