feat(transformer_plugins): add changed field to InjectGlobalVariablesReturn (#14618)

## Summary

Add a `changed: bool` field to `InjectGlobalVariablesReturn` to track whether the AST was modified during the global variable injection transformation.

- Adds `changed` field to `InjectGlobalVariablesReturn` struct
- Tracks changes via consolidated `mark_as_changed()` helper method
- Updates `replace_dot_defines` when dot define replacements occur
- Updates `inject_imports` when import statements are injected
- Updates `build` method to return `changed` in all paths

This allows callers to efficiently determine if injections or replacements were made without needing to compare the AST before and after transformation.

## Test plan

- [x] All existing tests pass
- [x] No new tests needed - change tracking is straightforward

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: Boshen

crates/oxc_transformer_plugins/src/inject_global_variables.rs

@@ -111,6 +111,7 @@ impl From<&InjectImport> for DotDefineState<'_> {
 #[must_use]
 pub struct InjectGlobalVariablesReturn {
     pub scoping: Scoping,
+    pub changed: bool,
 }
 
 /// Injects import statements for global variables.
@@ -129,6 +130,8 @@ pub struct InjectGlobalVariables<'a> {
     /// Identifiers for which dot define replaced a member expression.
     replaced_dot_defines:
         Vec<(/* identifier of member expression */ CompactStr, /* local */ CompactStr)>,
+
+    changed: bool,
 }
 
 impl<'a> Traverse<'a, ()> for InjectGlobalVariables<'a> {
@@ -144,9 +147,14 @@ impl<'a> InjectGlobalVariables<'a> {
             config,
             dot_defines: vec![],
             replaced_dot_defines: vec![],
+            changed: false,
         }
     }
 
+    fn mark_as_changed(&mut self) {
+        self.changed = true;
+    }
+
     pub fn build(
         &mut self,
         scoping: Scoping,
@@ -193,15 +201,15 @@ impl<'a> InjectGlobalVariables<'a> {
             .collect::<Vec<_>>();
 
         if injects.is_empty() {
-            return InjectGlobalVariablesReturn { scoping };
+            return InjectGlobalVariablesReturn { scoping, changed: self.changed };
         }
 
         self.inject_imports(&injects, program);
 
-        InjectGlobalVariablesReturn { scoping }
+        InjectGlobalVariablesReturn { scoping, changed: self.changed }
     }
 
-    fn inject_imports(&self, injects: &[InjectImport], program: &mut Program<'a>) {
+    fn inject_imports(&mut self, injects: &[InjectImport], program: &mut Program<'a>) {
         let imports = injects.iter().map(|inject| {
             let specifiers = Some(self.ast.vec1(self.inject_import_to_specifier(inject)));
             let source = self.ast.string_literal(SPAN, self.ast.atom(&inject.source), None);
@@ -212,6 +220,7 @@ impl<'a> InjectGlobalVariables<'a> {
             Statement::from(import_decl)
         });
         program.body.splice(0..0, imports);
+        self.mark_as_changed();
     }
 
     fn inject_import_to_specifier(&self, inject: &InjectImport) -> ImportDeclarationSpecifier<'a> {
@@ -269,6 +278,7 @@ impl<'a> InjectGlobalVariables<'a> {
 
                     let value = self.ast.expression_identifier(SPAN, value_atom);
                     *expr = value;
+                    self.mark_as_changed();
                     break;
                 }
             }

crates/oxc_transformer_plugins/tests/integrations/inject_global_variables.rs

@@ -18,7 +18,8 @@ fn test(source_text: &str, expected: &str, config: InjectGlobalVariablesConfig)
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let mut program = ret.program;
     let scoping = SemanticBuilder::new().build(&program).semantic.into_scoping();
-    let _ = InjectGlobalVariables::new(&allocator, config).build(scoping, &mut program);
+    let ret = InjectGlobalVariables::new(&allocator, config).build(scoping, &mut program);
+    assert_eq!(ret.changed, source_text != expected);
     let result = Codegen::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(&program)