Add EnumMutation and EnumMemberMutation to the Mutator Framework (#9133)

### Summary

Completes enum support in the mutator framework by adding the missing
high-level mutation classes. The low-level `EnumMutationNode` and
`EnumMemberMutationNode` were added in #8822, but the corresponding
`EnumMutation` and `EnumMemberMutation` classes were not implemented.

### Changes

- Add `EnumMutation` class for customizing enum mutations
- Add `EnumMemberMutation` class for customizing enum member mutations  
- Register both classes in `MutationEngine` and `DefaultMutationClasses`
- Add exports to `mutation/index.ts`
- Add integration test demonstrating custom enum mutations

### Testing

- Added test for custom `EnumMutation` that renames enums and their
members
- Expanded existing `mutation-node/enum.test.ts` with tests for:
  - Basic member mutation
  - Member deletion

Author: FionaBronwen

.chronus/changes/fionabronwen-mutator-framework-2025-11-3-22-19-48.md

@@ -0,0 +1,8 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: feature
+packages:
+  - "@typespec/mutator-framework"
+---
+
+Add `EnumMutation` and `EnumMemberMutation` to the Mutator Framework

packages/mutator-framework/CHANGELOG.md

@@ -1,7 +1,5 @@
 # Changelog - @typespec/mutator-framework
 
-
-
 ## 0.13.0
 
 ### Features
@@ -11,4 +9,3 @@
 ### Bump dependencies
 
 - [#8823](https://github.com/microsoft/typespec/pull/8823) Upgrade dependencies
-

packages/mutator-framework/src/mutation-node/enum-member.test.ts

@@ -2,6 +2,7 @@ import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, expect, it } from "vitest";
 import { Tester } from "../../test/test-host.js";
 import { getSubgraph } from "../../test/utils.js";
+
 let runner: TesterInstance;
 beforeEach(async () => {
   runner = await Tester.createInstance();

packages/mutator-framework/src/mutation-node/enum.test.ts

@@ -2,6 +2,7 @@ import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, expect, it } from "vitest";
 import { Tester } from "../../test/test-host.js";
 import { getSubgraph } from "../../test/utils.js";
+
 let runner: TesterInstance;
 beforeEach(async () => {
   runner = await Tester.createInstance();
@@ -15,12 +16,47 @@ it("handles mutation of members", async () => {
       }
     `);
 
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const aNode = subgraph.getNode(a);
+  aNode.mutate();
+  expect(aNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.members.get("a") === aNode.mutatedType).toBe(true);
+});
+
+it("handles mutation of members with name change", async () => {
+  const { program, Foo, a } = await runner.compile(t.code`
+      enum ${t.enum("Foo")} {
+        ${t.enumMember("a")};
+        b;
+      }
+    `);
+
   const subgraph = getSubgraph(program);
   const fooNode = subgraph.getNode(Foo);
   const aNode = subgraph.getNode(a);
   aNode.mutate((clone) => (clone.name = "aRenamed"));
   expect(aNode.isMutated).toBe(true);
   expect(fooNode.isMutated).toBe(true);
-  expect(fooNode.mutatedType.members.get("a") === undefined).toBeTruthy();
-  expect(fooNode.mutatedType.members.get("aRenamed") === aNode.mutatedType).toBeTruthy();
+  expect(fooNode.mutatedType.members.get("a")).toBeUndefined();
+  expect(fooNode.mutatedType.members.get("aRenamed") === aNode.mutatedType).toBe(true);
+});
+
+it("handles deletion of members", async () => {
+  const { program, Foo, a } = await runner.compile(t.code`
+      enum ${t.enum("Foo")} {
+        ${t.enumMember("a")};
+        b;
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const aNode = subgraph.getNode(a);
+  aNode.delete();
+  expect(aNode.isDeleted).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.members.get("a")).toBeUndefined();
+  expect(fooNode.mutatedType.members.size).toBe(1);
 });

packages/mutator-framework/src/mutation-node/index.ts

@@ -1,5 +1,6 @@
 export * from "./mutation-node.js";
 
+export * from "./enum-member.js";
 export * from "./enum.js";
 export * from "./interface.js";
 export * from "./intrinsic.js";
@@ -13,4 +14,3 @@ export * from "./scalar.js";
 export * from "./tuple.js";
 export * from "./union-variant.js";
 export * from "./union.js";
-//export * from "./enum-member.js";

packages/mutator-framework/src/mutation/enum-member.ts

@@ -0,0 +1,24 @@
+import type { EnumMember, MemberType } from "@typespec/compiler";
+import type { CustomMutationClasses, MutationEngine, MutationOptions } from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class EnumMemberMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<EnumMember, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "EnumMember";
+
+  constructor(
+    engine: TEngine,
+    sourceType: EnumMember,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  mutate() {
+    // EnumMember is a leaf type with no children to mutate
+  }
+}

packages/mutator-framework/src/mutation/enum.ts

@@ -0,0 +1,36 @@
+import type { Enum, MemberType } from "@typespec/compiler";
+import type {
+  CustomMutationClasses,
+  MutationEngine,
+  MutationFor,
+  MutationOptions,
+} from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class EnumMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<Enum, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "Enum";
+  members: Map<string, MutationFor<TCustomMutations, "EnumMember">> = new Map();
+
+  constructor(
+    engine: TEngine,
+    sourceType: Enum,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  protected mutateMembers() {
+    for (const member of this.sourceType.members.values()) {
+      this.members.set(member.name, this.engine.mutate(member, this.options));
+    }
+  }
+
+  mutate() {
+    this.mutateMembers();
+  }
+}

packages/mutator-framework/src/mutation/index.ts

@@ -1,3 +1,5 @@
+export * from "./enum-member.js";
+export * from "./enum.js";
 export * from "./interface.js";
 export * from "./intrinsic.js";
 export * from "./literal.js";

packages/mutator-framework/src/mutation/mutation-engine.test.ts

@@ -1,9 +1,11 @@
-import type { Model } from "@typespec/compiler";
+import type { Enum, Model } from "@typespec/compiler";
 import { t } from "@typespec/compiler/testing";
 import { $, type Typekit } from "@typespec/compiler/typekit";
 import { expect, it } from "vitest";
 import { Tester } from "../../test/test-host.js";
 import type { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import { EnumMemberMutation } from "./enum-member.js";
+import { EnumMutation } from "./enum.js";
 import { ModelPropertyMutation } from "./model-property.js";
 import { ModelMutation } from "./model.js";
 import { MutationEngine, MutationOptions } from "./mutation-engine.js";
@@ -200,3 +202,70 @@ it("mutates model properties into unions", async () => {
   const mutatedFoo = fooMutation.unionified;
   expect(tk.union.is(mutatedFoo.properties.get("prop")!.type)).toBe(true);
 });
+
+interface RenameEnumMutations {
+  Enum: RenameEnumMutation;
+  EnumMember: RenameEnumMemberMutation;
+}
+
+class RenameEnumMutation extends EnumMutation<
+  RenameMutationOptions,
+  RenameEnumMutations,
+  MutationEngine<RenameEnumMutations>
+> {
+  get withPrefix() {
+    return this.getMutatedType();
+  }
+
+  mutate() {
+    this.mutateType((e) => (e.name = `${this.options.prefix}${this.sourceType.name}`));
+    super.mutate();
+  }
+}
+
+class RenameEnumMemberMutation extends EnumMemberMutation<
+  RenameMutationOptions,
+  RenameEnumMutations,
+  MutationEngine<RenameEnumMutations>
+> {
+  get withPrefix() {
+    return this.getMutatedType();
+  }
+
+  mutate() {
+    this.mutateType((m) => (m.name = `${this.options.prefix}${this.sourceType.name}`));
+    super.mutate();
+  }
+}
+
+it("mutates enums and enum members", async () => {
+  const runner = await Tester.createInstance();
+  const { Status, program } = await runner.compile(t.code`
+    enum ${t.enum("Status")} {
+      Active,
+      Inactive,
+    }
+  `);
+
+  const tk = $(program);
+  const engine = new SimpleMutationEngine(tk, {
+    Enum: RenameEnumMutation,
+    EnumMember: RenameEnumMemberMutation,
+  });
+
+  const options = new RenameMutationOptions("Pre", "Suf");
+  const enumMutation = engine.mutate(Status, options) as RenameEnumMutation;
+
+  // Verify the enum and its members are mutated
+  expect(enumMutation.withPrefix.name).toBe("PreStatus");
+
+  const activeMutation = enumMutation.members.get("Active") as RenameEnumMemberMutation;
+  expect(activeMutation.withPrefix.name).toBe("PreActive");
+
+  // Verify the mutated enum has the renamed members
+  const mutatedEnum = enumMutation.withPrefix as Enum;
+  expect(mutatedEnum.members.has("PreActive")).toBe(true);
+  expect(mutatedEnum.members.has("PreInactive")).toBe(true);
+  expect(mutatedEnum.members.has("Active")).toBe(false);
+  expect(mutatedEnum.members.has("Inactive")).toBe(false);
+});

packages/mutator-framework/src/mutation/mutation-engine.ts

@@ -2,6 +2,8 @@ import type { MemberType, Type } from "@typespec/compiler";
 import type { Typekit } from "@typespec/compiler/typekit";
 import type { MutationNodeForType } from "../mutation-node/factory.js";
 import { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import { EnumMemberMutation } from "./enum-member.js";
+import { EnumMutation } from "./enum.js";
 import { InterfaceMutation } from "./interface.js";
 import { IntrinsicMutation } from "./intrinsic.js";
 import { LiteralMutation } from "./literal.js";
@@ -24,6 +26,8 @@ export interface DefaultMutationClasses<TCustomMutations extends CustomMutationC
   ModelProperty: ModelPropertyMutation<MutationOptions, TCustomMutations>;
   Union: UnionMutation<MutationOptions, TCustomMutations>;
   UnionVariant: UnionVariantMutation<MutationOptions, TCustomMutations>;
+  Enum: EnumMutation<MutationOptions, TCustomMutations>;
+  EnumMember: EnumMemberMutation<MutationOptions, TCustomMutations>;
   String: LiteralMutation<MutationOptions, TCustomMutations>;
   Number: LiteralMutation<MutationOptions, TCustomMutations>;
   Boolean: LiteralMutation<MutationOptions, TCustomMutations>;
@@ -72,6 +76,8 @@ export class MutationEngine<TCustomMutations extends CustomMutationClasses> {
       ModelProperty: mutatorClasses.ModelProperty ?? ModelPropertyMutation,
       Union: mutatorClasses.Union ?? UnionMutation,
       UnionVariant: mutatorClasses.UnionVariant ?? UnionVariantMutation,
+      Enum: mutatorClasses.Enum ?? EnumMutation,
+      EnumMember: mutatorClasses.EnumMember ?? EnumMemberMutation,
       String: mutatorClasses.String ?? LiteralMutation,
       Number: mutatorClasses.Number ?? LiteralMutation,
       Boolean: mutatorClasses.Boolean ?? LiteralMutation,