fix(federation): update field types and member references when renaming a union

`UnionTypeDefinitionPosition::rename` only re-keyed the union's reference
record. Object and interface fields that return the union kept the old, removed
name, making the schema invalid. The reference index also kept the old name in
each member object's `union_types` set and in the union's `__typename` field
position.

The union rename now rewrites the types of referencing fields, preserving list
and non-null wrappers, and `Referencers::rename_union_type` remaps the member
and `__typename` positions. The regression compares the index with one rebuilt
from the edited schema.

Author: inanna-apollo

apollo-federation/src/schema/position.rs

@@ -5722,6 +5722,12 @@ impl UnionTypeDefinitionPosition {
         if let Some(union_type_referencers) =
             schema.referencers.union_types.swap_remove(&self.type_name)
         {
+            for pos in union_type_referencers.object_fields.iter() {
+                pos.rename_type(schema, new_name.clone())?;
+            }
+            for pos in union_type_referencers.interface_fields.iter() {
+                pos.rename_type(schema, new_name.clone())?;
+            }
             schema
                 .referencers
                 .union_types
@@ -8383,4 +8389,189 @@ mod tests {
             }
         "#);
     }
+
+    /// Flattens a referencer index into an order-independent set of facts, so an incrementally
+    /// maintained index can be compared with one rebuilt from scratch.
+    fn referencer_facts(referencers: &Referencers) -> std::collections::BTreeSet<String> {
+        fn add<T: Debug>(
+            facts: &mut std::collections::BTreeSet<String>,
+            kind: &str,
+            key: &Name,
+            slot: &str,
+            positions: impl IntoIterator<Item = T>,
+        ) {
+            facts.insert(format!("{kind} {key}"));
+            for position in positions {
+                facts.insert(format!("{kind} {key} {slot} {position:?}"));
+            }
+        }
+        let mut facts = std::collections::BTreeSet::new();
+        let f = &mut facts;
+        for (key, r) in &referencers.scalar_types {
+            add(f, "scalar", key, "object_fields", &r.object_fields);
+            add(
+                f,
+                "scalar",
+                key,
+                "object_field_arguments",
+                &r.object_field_arguments,
+            );
+            add(f, "scalar", key, "interface_fields", &r.interface_fields);
+            add(
+                f,
+                "scalar",
+                key,
+                "interface_field_arguments",
+                &r.interface_field_arguments,
+            );
+            add(f, "scalar", key, "union_fields", &r.union_fields);
+            add(
+                f,
+                "scalar",
+                key,
+                "input_object_fields",
+                &r.input_object_fields,
+            );
+            add(
+                f,
+                "scalar",
+                key,
+                "directive_arguments",
+                &r.directive_arguments,
+            );
+        }
+        for (key, r) in &referencers.object_types {
+            add(f, "object", key, "schema_roots", &r.schema_roots);
+            add(f, "object", key, "object_fields", &r.object_fields);
+            add(f, "object", key, "interface_fields", &r.interface_fields);
+            add(f, "object", key, "union_types", &r.union_types);
+        }
+        for (key, r) in &referencers.interface_types {
+            add(f, "interface", key, "object_types", &r.object_types);
+            add(f, "interface", key, "object_fields", &r.object_fields);
+            add(f, "interface", key, "interface_types", &r.interface_types);
+            add(f, "interface", key, "interface_fields", &r.interface_fields);
+        }
+        for (key, r) in &referencers.union_types {
+            add(f, "union", key, "object_fields", &r.object_fields);
+            add(f, "union", key, "interface_fields", &r.interface_fields);
+        }
+        for (key, r) in &referencers.enum_types {
+            add(f, "enum", key, "object_fields", &r.object_fields);
+            add(
+                f,
+                "enum",
+                key,
+                "object_field_arguments",
+                &r.object_field_arguments,
+            );
+            add(f, "enum", key, "interface_fields", &r.interface_fields);
+            add(
+                f,
+                "enum",
+                key,
+                "interface_field_arguments",
+                &r.interface_field_arguments,
+            );
+            add(
+                f,
+                "enum",
+                key,
+                "input_object_fields",
+                &r.input_object_fields,
+            );
+            add(
+                f,
+                "enum",
+                key,
+                "directive_arguments",
+                &r.directive_arguments,
+            );
+        }
+        for (key, r) in &referencers.input_object_types {
+            add(
+                f,
+                "input",
+                key,
+                "object_field_arguments",
+                &r.object_field_arguments,
+            );
+            add(
+                f,
+                "input",
+                key,
+                "interface_field_arguments",
+                &r.interface_field_arguments,
+            );
+            add(
+                f,
+                "input",
+                key,
+                "input_object_fields",
+                &r.input_object_fields,
+            );
+            add(
+                f,
+                "input",
+                key,
+                "directive_arguments",
+                &r.directive_arguments,
+            );
+        }
+        for (key, r) in &referencers.directives {
+            add(f, "directive", key, "targets", r.iter());
+        }
+        facts
+    }
+
+    /// Renames a type through the public entry point, then checks the edit contract: the compiler
+    /// schema is still valid, and the incrementally maintained referencers equal referencers
+    /// rebuilt from scratch from the edited schema.
+    fn rename_and_check(sdl: &str, old_name: Name, new_name: Name) -> FederationSchema {
+        let mut schema = FederationSchema::new(
+            Schema::parse_and_validate(sdl, "rename.graphql")
+                .unwrap()
+                .into_inner(),
+        )
+        .unwrap();
+        schema
+            .get_type(&old_name)
+            .unwrap()
+            .rename(&mut schema, new_name)
+            .unwrap();
+        let valid = schema.schema().clone().validate();
+        assert!(valid.is_ok(), "renamed schema is invalid: {valid:?}");
+        let rebuilt = FederationSchema::new(schema.schema().clone()).unwrap();
+        let actual = referencer_facts(schema.referencers());
+        let expected = referencer_facts(rebuilt.referencers());
+        let stale: Vec<_> = actual.difference(&expected).collect();
+        let missing: Vec<_> = expected.difference(&actual).collect();
+        assert!(
+            stale.is_empty() && missing.is_empty(),
+            "referencers diverge from a rebuild after renaming {old_name}\n\
+             stale: {stale:#?}\nmissing: {missing:#?}"
+        );
+        schema
+    }
+
+    #[test]
+    fn renamed_union_updates_output_field_types() {
+        let schema = rename_and_check(
+            "type Member { id: ID! } union Choice = Member \
+             interface Holder { held: [Choice!] } \
+             type Query implements Holder { result: Choice! held: [Choice!] }",
+            name!("Choice"),
+            name!("MovedChoice"),
+        );
+        let query = ObjectTypeDefinitionPosition::new(name!("Query"));
+        let result = query.field(name!("result")).get(schema.schema()).unwrap();
+        assert_eq!(result.ty.to_string(), "MovedChoice!");
+        let held = InterfaceTypeDefinitionPosition {
+            type_name: name!("Holder"),
+        }
+        .field(name!("held"))
+        .get(schema.schema())
+        .unwrap();
+        assert_eq!(held.ty.to_string(), "[MovedChoice!]");
+    }
 }

apollo-federation/src/schema/referencer.rs

@@ -345,6 +345,18 @@ impl Referencers {
     }
 
     pub(crate) fn rename_union_type(&mut self, old_name: &Name, new_name: &Name) {
+        for (_scalar_name, scalar_refs) in self.scalar_types.iter_mut() {
+            Self::update_union_typename_field_positions(
+                &mut scalar_refs.union_fields,
+                old_name,
+                new_name,
+            );
+        }
+
+        for (_object_name, object_refs) in self.object_types.iter_mut() {
+            Self::update_union_type_positions(&mut object_refs.union_types, old_name, new_name);
+        }
+
         for (_directive_name, directive_refs) in self.directives.iter_mut() {
             Self::update_union_type_positions(&mut directive_refs.union_types, old_name, new_name);
         }
@@ -367,6 +379,23 @@ impl Referencers {
         types.extend(updated_types);
     }
 
+    fn update_union_typename_field_positions(
+        fields: &mut IndexSet<UnionTypenameFieldDefinitionPosition>,
+        old_type_name: &Name,
+        new_type_name: &Name,
+    ) {
+        let updated_fields: Vec<_> = fields
+            .iter()
+            .filter(|f| &f.type_name == old_type_name)
+            .map(|_| UnionTypenameFieldDefinitionPosition {
+                type_name: new_type_name.clone(),
+            })
+            .collect();
+
+        fields.retain(|f| &f.type_name != old_type_name);
+        fields.extend(updated_fields);
+    }
+
     pub(crate) fn rename_enum_type(&mut self, old_name: &Name, new_name: &Name) {
         for (_directive_name, directive_refs) in self.directives.iter_mut() {
             Self::update_enum_type_positions(&mut directive_refs.enum_types, old_name, new_name);