[mutator] Keep isGenerator and isAsync properties when mutating method

Bug: 537297697
Change-Id: I11cf5bd8d7bd8d88428cf0c97fb7b59016281d7c
Reviewed-on: https://chrome-internal-review.googlesource.com/c/v8/fuzzilli/+/9614595
Reviewed-by: Matthias Liedtke <mliedtke@google.com>
Commit-Queue: Raphaël Hérouart <rherouart@google.com>

Author: rherouart-collab

Sources/Fuzzilli/Mutators/OperationMutator.swift

@@ -128,7 +128,8 @@ public class OperationMutator: BaseInstructionMutator {
             newOp = ObjectLiteralAddElement(index: b.randomIndex())
         case .beginObjectLiteralMethod(let op):
             newOp = BeginObjectLiteralMethod(
-                methodName: b.randomMethodName(), parameters: op.parameters)
+                methodName: b.randomMethodName(), parameters: op.parameters,
+                isGenerator: op.isGenerator, isAsync: op.isAsync)
         case .beginObjectLiteralGetter:
             newOp = BeginObjectLiteralGetter(propertyName: b.randomPropertyName())
         case .beginObjectLiteralSetter:
@@ -141,7 +142,8 @@ public class OperationMutator: BaseInstructionMutator {
                 index: b.randomIndex(), hasValue: op.hasValue, isStatic: op.isStatic)
         case .beginClassMethod(let op):
             newOp = BeginClassMethod(
-                methodName: b.randomMethodName(), parameters: op.parameters, isStatic: op.isStatic)
+                methodName: b.randomMethodName(), parameters: op.parameters, isStatic: op.isStatic,
+                isGenerator: op.isGenerator, isAsync: op.isAsync)
         case .beginClassGetter(let op):
             newOp = BeginClassGetter(propertyName: b.randomPropertyName(), isStatic: op.isStatic)
         case .beginClassSetter(let op):

Tests/FuzzilliTests/MutatorTests.swift

@@ -811,4 +811,52 @@ struct MutatorTests {
             try testCase.verify(mutatedProg)
         }
     }
+
+    @Test func testOperationMutatorPreservesGeneratorAndAsyncFlagsOnClassMethod() {
+        let fuzzer = makeMockFuzzer()
+        fuzzer.sync {
+            let b = fuzzer.makeBuilder()
+
+            b.buildClassDefinition { cls in
+                cls.addInstanceMethod(
+                    "m", with: .parameters(n: 0), isGenerator: true, isAsync: true
+                ) { _ in }
+            }
+            b.buildObjectLiteral { obj in
+                obj.addMethod("m2", with: .parameters(n: 0), isGenerator: true, isAsync: true) {
+                    _ in
+                }
+            }
+
+            let prog = b.finalize()
+
+            let mutator = OperationMutator()
+            let newBuilder = fuzzer.makeBuilder()
+
+            newBuilder.adopting {
+                for instr in prog.code {
+                    if instr.op is BeginClassMethod || instr.op is BeginObjectLiteralMethod {
+                        mutator.mutate(instr, newBuilder)
+                    } else {
+                        newBuilder.adopt(instr)
+                    }
+                }
+            }
+
+            let mutatedProg = newBuilder.finalize()
+            let mutatedClassMethod =
+                mutatedProg.code.first(where: { $0.op is BeginClassMethod })!.op
+                as! BeginClassMethod
+            #expect(mutatedClassMethod.isAsync == true)
+            #expect(mutatedClassMethod.isGenerator == true)
+
+            let mutatedObjMethod =
+                mutatedProg.code.first(where: { $0.op is BeginObjectLiteralMethod })!.op
+                as! BeginObjectLiteralMethod
+            #expect(mutatedObjMethod.isAsync == true)
+            #expect(mutatedObjMethod.isGenerator == true)
+
+            mutatedProg.checkOrDie(onFailure: "Program must be statically valid")
+        }
+    }
 }