[rebase] Delete code re-introduced by rebase to main

findOrGenerateArguments is supposed to use findOrGenerateType, as there
is unnecessary code sharing otherwise. In the wasm branch, this was
already fixed, but when it got rebased to main, the fix was undone
again.

Change-Id: I651e3c8c150a85e550752559cdf6eab432fe4b9b
Reviewed-on: https://chrome-internal-review.googlesource.com/c/v8/fuzzilli/+/7967835
Commit-Queue: Andreas Haas <[email protected]>
Reviewed-by: Carl Smith <[email protected]>

Author: gahaas

Sources/Fuzzilli/Base/ProgramBuilder.swift

@@ -505,103 +505,6 @@ public class ProgramBuilder {
 
     private func findOrGenerateArgumentsInternal(forSignature: Signature) -> [Variable] {
         var args: [Variable] = []
-
-        // This should be called whenever we have a type that has known information about its properties but we don't have a constructor for it.
-        // This can be the case for configuration objects, e.g. objects that can be passed into DOMAPIs.
-        func createObjectWithProperties(_ type: ILType) -> Variable  {
-            assert(type.MayBe(.object()))
-
-            // Before we do any generation below, let's take into account that we already create a variable with this invocation, i.e. the createObject at the end.
-            // Therefore we need to decrease the budget here temporarily.
-            self.argumentGenerationVariableBudget! -= 1
-            // We defer the increase again, because at that point the variable is actually visible, i.e. `numVariables` was increased through the `createObject` call.
-            defer { self.argumentGenerationVariableBudget! += 1 }
-
-            var properties: [String: Variable] = [:]
-
-            for propertyName in type.properties {
-                // If we have an object that has a group, we should get a type here, otherwise if we don't have a group, we will get .anything.
-                let propType = fuzzer.environment.type(ofProperty: propertyName, on: type)
-                properties[propertyName] = generateType(propType)
-            }
-
-            return createObject(with: properties)
-        }
-
-        func createObjectWithGroup(type: ILType) -> Variable {
-            let group = type.group!
-
-            // We can be sure that we have such a builtin with a signature because the Environment checks this during initialization.
-            let signature = fuzzer.environment.type(ofBuiltin: group).signature!
-            let constructor = createNamedVariable(forBuiltin: group)
-            let arguments = findOrGenerateArgumentsInternal(forSignature: signature)
-            let constructed = construct(constructor, withArgs: arguments)
-
-            return constructed
-        }
-
-        func generateType(_ type: ILType) -> Variable {
-            if probability(0.5) {
-                if let existingVariable = randomVariable(ofType: type) {
-                    return existingVariable
-                }
-            }
-
-            if numVariables >= argumentGenerationVariableBudget! {
-                logger.warning("Reached variable generation limit in generateType for Signature: \(argumentGenerationSignature!), returning a random variable for use as type \(type).")
-                return randomVariable(forUseAs: type)
-            }
-
-            // We only need to check against all base types from TypeSystem.swift, this works because we use .MayBe
-            // TODO: Not sure how we should handle merge types, e.g. .string + .object(...).
-            let typeGenerators: [(ILType, () -> Variable)] = [
-                (.integer, { return self.loadInt(self.randomInt()) }),
-                (.string, { return self.loadString(self.randomString()) }),
-                (.boolean, { return self.loadBool(probability(0.5)) }),
-                (.bigint, { return self.loadBigInt(self.randomInt()) }),
-                (.float, { return self.loadFloat(self.randomFloat()) }),
-                (.regexp, {
-                     let (pattern, flags) = self.randomRegExpPatternAndFlags()
-                     return self.loadRegExp(pattern, flags)
-                 }),
-                (.iterable, { return self.createArray(with: self.randomVariables(upTo: 5)) }),
-                (.function(), {
-                     // TODO: We could technically generate a full function here but then we would enter the full code generation logic which could do anything.
-                     // Because we want to avoid this, we will just pick anything that can be a function.
-                     return self.randomVariable(forUseAs: .function())
-                 }),
-                (.undefined, { return self.loadUndefined() }),
-                (.constructor(), {
-                     // TODO: We have the same issue as above for functions.
-                     return self.randomVariable(forUseAs: .constructor())
-                 }),
-                (.object(), {
-                     // If we have a group on this object and we have a builtin, that means we can construct it with new.
-                     if let group = type.group, self.fuzzer.environment.hasBuiltin(group) && self.fuzzer.environment.type(ofBuiltin: group).Is(.constructor()) {
-                         return createObjectWithGroup(type: type)
-                     } else {
-                         // Otherwise this is one of the following:
-                         // 1. an object with more type information, i.e. it has a group, but no associated builtin, e.g. we cannot construct it with new.
-                         // 2. an object without a group, but it has some required fields.
-                         // In either case, we try to construct such an object.
-                         return createObjectWithProperties(type)
-                     }
-                 })
-            ]
-
-            // Make sure that we walk over these tests and their generators randomly.
-            // The requested type could be a Union of other types and as such we want to randomly generate one of them, therefore we also use the MayBe test below.
-            for (t, generate) in typeGenerators.shuffled() {
-                if type.MayBe(t) {
-                    let variable = generate()
-                    return variable
-                }
-            }
-
-            logger.warning("Type \(type) was not handled, returning random variable.")
-            return randomVariable(forUseAs: type)
-        }
-
         outer: for parameter in forSignature.parameters {
             switch parameter {
             case .plain(let t):