fix(federation): keep renamed interfaces in their directives' referencers

Renaming an interface type left the old interface name in
`Referencers.directives[d].interface_types` for every directive applied to it.
The schema stayed valid, but directive lookups through the index (as used for
`@key`, `@tag`, `@inaccessible` and other directive processing) named a type
that no longer existed.

`Referencers::rename_interface_type` now remaps directive target positions for
the interface itself, as it already did for its fields and arguments.

Author: inanna-apollo

apollo-federation/src/schema/position.rs

@@ -8383,4 +8383,184 @@ 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_interface_keeps_its_directive_referencer_position() {
+        let schema = rename_and_check(
+            "directive @mark on INTERFACE interface I @mark { x: String } type Query { i: I }",
+            name!("I"),
+            name!("Renamed"),
+        );
+        let targets = &schema.referencers().directives["mark"].interface_types;
+        assert!(targets.contains(&InterfaceTypeDefinitionPosition {
+            type_name: name!("Renamed")
+        }));
+        assert!(!targets.contains(&InterfaceTypeDefinitionPosition {
+            type_name: name!("I")
+        }));
+    }
 }

apollo-federation/src/schema/referencer.rs

@@ -519,6 +519,11 @@ impl Referencers {
         }
 
         for (_directive_name, directive_refs) in self.directives.iter_mut() {
+            Self::update_interface_type_positions(
+                &mut directive_refs.interface_types,
+                old_name,
+                new_name,
+            );
             Self::update_interface_field_positions(
                 &mut directive_refs.interface_fields,
                 old_name,
@@ -532,6 +537,23 @@ impl Referencers {
         }
     }
 
+    fn update_interface_type_positions(
+        types: &mut IndexSet<InterfaceTypeDefinitionPosition>,
+        old_type_name: &Name,
+        new_type_name: &Name,
+    ) {
+        let updated_types: Vec<_> = types
+            .iter()
+            .filter(|t| &t.type_name == old_type_name)
+            .map(|_| InterfaceTypeDefinitionPosition {
+                type_name: new_type_name.clone(),
+            })
+            .collect();
+
+        types.retain(|t| &t.type_name != old_type_name);
+        types.extend(updated_types);
+    }
+
     fn update_interface_field_positions(
         fields: &mut IndexSet<InterfaceFieldDefinitionPosition>,
         old_type_name: &Name,