Rename ProgramBuilder.randXYZ to ProgramBuilder.randomXYZ

Author: Samuel Groß

Docs/HowFuzzilliWorks.md

@@ -210,8 +210,8 @@ Up to this point, a code generator is a simple function that fetches zero or mor
 
 ```swift
 CodeGenerator("FunctionCallGenerator") { b in
-    let function = b.randVar()
-    let arguments = [b.randVar(), b.randVar(), b.randVar()]
+    let function = b.randomVariable()
+    let arguments = [b.randomVariable(), b.randomVariable(), b.randomVariable()]
     b.callFunction(f, with: arguments)
 }
 ```
@@ -261,8 +261,8 @@ With type information available, the CodeGenerator from above can now request a
 
 ```swift
 CodeGenerator("FunctionCallGenerator") { b in
-    let function = b.randVar(ofType: .function())
-    let arguments = b.randArguments(forCalling: function)
+    let function = b.randomVariable(ofType: .function())
+    let arguments = b.randomCallArguments(forCalling: function)
     b.callFunction(f, with: arguments)
 }
 ```

Sources/Fuzzilli/Base/ProgramBuilder.swift

@@ -142,9 +142,9 @@ public let ProgramTemplates = [
             b.build(n: 5)
             let array = b.generateVariable(ofType: .object(ofGroup: "Array"))
 
-            let index = b.randIndex()
+            let index = b.randomIndex()
             b.getElement(index, of: array)
-            b.doReturn(b.randVar())
+            b.doReturn(b.randomVariable())
         }
 
         // TODO: check if these are actually different, or if

Sources/Fuzzilli/CodeGen/CodeGenerators.swift

@@ -46,26 +46,26 @@ struct MinimizationPostProcessor {
                      .endObjectLiteralGetter:
                     // Insert return statements at the end of functions, but only if there is not one already.
                     if lastInstr.op is Return || !b.hasVisibleVariables { break }
-                    addedInstruction = Instruction(Return(), inputs: [b.randVar()])
+                    addedInstruction = Instruction(Return(), inputs: [b.randomVariable()])
                 case .callFunction:
                     // (Sometimes) insert random arguments, but only if there are none currently.
                     if instr.hasAnyVariadicInputs || !b.hasVisibleVariables || probability(0.5) { break }
-                    guard let args = b.randCallArguments(for: instr.input(0)), args.count > 0 else { break }
+                    guard let args = b.randomCallArguments(for: instr.input(0)), args.count > 0 else { break }
                     replacementInstruction = Instruction(CallFunction(numArguments: args.count), output: instr.output, inputs: [instr.input(0)] + args)
                 case .callMethod(let op):
                     // (Sometimes) insert random arguments, but only if there are none currently.
                     if instr.hasAnyVariadicInputs || !b.hasVisibleVariables || probability(0.5) { break }
-                    guard let args = b.randCallArguments(forMethod: op.methodName, on: instr.input(0)), args.count > 0 else { break }
+                    guard let args = b.randomCallArguments(forMethod: op.methodName, on: instr.input(0)), args.count > 0 else { break }
                     replacementInstruction = Instruction(CallMethod(methodName: op.methodName, numArguments: args.count), output: instr.output, inputs: [instr.input(0)] + args)
                 case .construct:
                     // (Sometimes) insert random arguments, but only if there are none currently.
                     if instr.hasAnyVariadicInputs || !b.hasVisibleVariables || probability(0.5) { break }
-                    guard let args = b.randCallArguments(for: instr.input(0)), args.count > 0 else { break }
+                    guard let args = b.randomCallArguments(for: instr.input(0)), args.count > 0 else { break }
                     replacementInstruction = Instruction(Construct(numArguments: args.count), output: instr.output, inputs: [instr.input(0)] + args)
                 case .createArray:
                     // Add initial values, but only if there are none currently.
                     if instr.hasAnyVariadicInputs || !b.hasVisibleVariables { break }
-                    let initialValues = Array<Variable>(repeating: b.randVar(), count: Int.random(in: 1...5))
+                    let initialValues = Array<Variable>(repeating: b.randomVariable(), count: Int.random(in: 1...5))
                     replacementInstruction = Instruction(CreateArray(numInitialValues: initialValues.count), output: instr.output, inputs: initialValues)
                 default:
                     assert(!(instr.op is EndAnyFunction))

Sources/Fuzzilli/CodeGen/ProgramTemplates.swift

@@ -233,7 +233,7 @@ public class ExplorationMutator: Mutator {
         var ids = [String]()
         // Helper function for inserting the Explore operation and tracking its id.
         func explore(_ v: Variable) {
-            let args = b.randVars(upTo: 5)
+            let args = b.randomVariables(upTo: 5)
             assert(args.count > 0)
             let id = String(v.number)
             assert(!ids.contains(id))

Sources/Fuzzilli/Minimization/PostProcessor.swift

@@ -50,9 +50,9 @@ public class InputMutator: BaseInstructionMutator {
         if isTypeAware {
             let type = b.type(of: inouts[selectedInput]).generalize()
             // We are guaranteed to find at least the current input.
-            replacement = b.randVar(ofType: type, excludeInnermostScope: instr.isBlockEnd)!
+            replacement = b.randomVariable(ofType: type, excludeInnermostScope: instr.isBlockEnd)!
         } else {
-            replacement = b.randVar(excludeInnermostScope: instr.isBlockEnd)
+            replacement = b.randomVariable(excludeInnermostScope: instr.isBlockEnd)
         }
         b.trace("Replacing input \(selectedInput) (\(inouts[selectedInput])) with \(replacement)")
         inouts[selectedInput] = replacement

Sources/Fuzzilli/Mutators/ExplorationMutator.swift

@@ -25,8 +25,8 @@ public class JITStressMutator: Mutator {
         b.build(n: defaultCodeGenerationAmount)
 
         // Call an existing (and hopefully JIT compiled) function again
-        guard let f = b.randVar(ofConservativeType: .function()) else { return nil }
-        guard let arguments = b.randCallArguments(for: f) else { return nil }
+        guard let f = b.randomVariable(ofConservativeType: .function()) else { return nil }
+        guard let arguments = b.randomCallArguments(for: f) else { return nil }
         b.callFunction(f, withArgs: arguments)
         return b.finalize()
     }