diff --git a/velox/expression/fuzzer/ArgGenerator.h b/velox/expression/fuzzer/ArgTypesGenerator.h
similarity index 94%
rename from velox/expression/fuzzer/ArgGenerator.h
rename to velox/expression/fuzzer/ArgTypesGenerator.h
index 4c015f7a38c7..233be4c617ff 100644
--- a/velox/expression/fuzzer/ArgGenerator.h
+++ b/velox/expression/fuzzer/ArgTypesGenerator.h
@@ -22,9 +22,9 @@ namespace facebook::velox::fuzzer {
 
 /// Generates random, but valid input types for a specified function signature
 /// with the return type.
-class ArgGenerator {
+class ArgTypesGenerator {
  public:
-  virtual ~ArgGenerator() = default;
+  virtual ~ArgTypesGenerator() = default;
 
   /// Given a signature and a concrete return type returns randomly selected
   /// valid input types. Returns empty vector if no input types can produce the
diff --git a/velox/expression/fuzzer/ArgsOverrideFunctions.cpp b/velox/expression/fuzzer/ArgValuesGenerators.cpp
similarity index 97%
rename from velox/expression/fuzzer/ArgsOverrideFunctions.cpp
rename to velox/expression/fuzzer/ArgValuesGenerators.cpp
index 093ef393e7f2..0caf7434a52d 100644
--- a/velox/expression/fuzzer/ArgsOverrideFunctions.cpp
+++ b/velox/expression/fuzzer/ArgValuesGenerators.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/expression/fuzzer/ArgsOverrideFunctions.h"
+#include "velox/expression/fuzzer/ArgValuesGenerators.h"
 
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/common/fuzzer/Utils.h"
diff --git a/velox/expression/fuzzer/ArgsOverrideFunctions.h b/velox/expression/fuzzer/ArgValuesGenerators.h
similarity index 100%
rename from velox/expression/fuzzer/ArgsOverrideFunctions.h
rename to velox/expression/fuzzer/ArgValuesGenerators.h
diff --git a/velox/expression/fuzzer/CMakeLists.txt b/velox/expression/fuzzer/CMakeLists.txt
index 57bcf9a94f5f..f2a950408e81 100644
--- a/velox/expression/fuzzer/CMakeLists.txt
+++ b/velox/expression/fuzzer/CMakeLists.txt
@@ -25,9 +25,9 @@ target_link_libraries(
 
 add_library(
   velox_expression_fuzzer
-  ArgsOverrideFunctions.cpp
+  ArgValuesGenerators.cpp
   ArgumentTypeFuzzer.cpp
-  DecimalArgGeneratorBase.cpp
+  DecimalArgTypesGeneratorBase.cpp
   ExpressionFuzzer.cpp
   ExpressionFuzzerVerifier.cpp
   FuzzerRunner.cpp
diff --git a/velox/expression/fuzzer/DecimalArgGeneratorBase.cpp b/velox/expression/fuzzer/DecimalArgTypesGeneratorBase.cpp
similarity index 91%
rename from velox/expression/fuzzer/DecimalArgGeneratorBase.cpp
rename to velox/expression/fuzzer/DecimalArgTypesGeneratorBase.cpp
index 1b65b67658c5..327720f4df1c 100644
--- a/velox/expression/fuzzer/DecimalArgGeneratorBase.cpp
+++ b/velox/expression/fuzzer/DecimalArgTypesGeneratorBase.cpp
@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
+
 #include <boost/random/uniform_int_distribution.hpp>
 
 namespace facebook::velox::fuzzer {
@@ -40,7 +41,7 @@ uint32_t rand32(uint32_t max, FuzzerGenerator& rng) {
 }
 } // namespace
 
-std::vector<TypePtr> DecimalArgGeneratorBase::generateArgs(
+std::vector<TypePtr> DecimalArgTypesGeneratorBase::generateArgs(
     const exec::FunctionSignature& /*signature*/,
     const TypePtr& returnType,
     FuzzerGenerator& rng) {
@@ -53,7 +54,7 @@ std::vector<TypePtr> DecimalArgGeneratorBase::generateArgs(
   return inputs;
 }
 
-void DecimalArgGeneratorBase::initialize(uint32_t numArgs) {
+void DecimalArgTypesGeneratorBase::initialize(uint32_t numArgs) {
   switch (numArgs) {
     case 1: {
       for (const auto& t : getAllTypes()) {
@@ -83,7 +84,7 @@ void DecimalArgGeneratorBase::initialize(uint32_t numArgs) {
   }
 }
 
-std::vector<TypePtr> DecimalArgGeneratorBase::findInputs(
+std::vector<TypePtr> DecimalArgTypesGeneratorBase::findInputs(
     const TypePtr& returnType,
     FuzzerGenerator& rng) const {
   const auto [p, s] = getDecimalPrecisionScale(*returnType);
diff --git a/velox/expression/fuzzer/DecimalArgGeneratorBase.h b/velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h
similarity index 95%
rename from velox/expression/fuzzer/DecimalArgGeneratorBase.h
rename to velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h
index c27db1b8d264..a5de0eb0900c 100644
--- a/velox/expression/fuzzer/DecimalArgGeneratorBase.h
+++ b/velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 
 namespace facebook::velox::fuzzer {
 
@@ -26,7 +26,7 @@ namespace facebook::velox::fuzzer {
 /// classes should call 'initialize' from the constructor and specify the number
 /// of decimal arguments. They should also implement toReturnType with matching
 /// number of pairs of precision and scale.
-class DecimalArgGeneratorBase : public ArgGenerator {
+class DecimalArgTypesGeneratorBase : public ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.cpp b/velox/expression/fuzzer/ExpressionFuzzer.cpp
index 89843d7c7b8a..90285c021f5d 100644
--- a/velox/expression/fuzzer/ExpressionFuzzer.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzer.cpp
@@ -272,15 +272,15 @@ ExpressionFuzzer::ExpressionFuzzer(
     size_t initialSeed,
     const std::shared_ptr<VectorFuzzer>& vectorFuzzer,
     const std::optional<ExpressionFuzzer::Options>& options,
-    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-        argGenerators,
+    const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+        argTypesGenerators,
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
-        argsOverrideFuncs)
+        argValuesGenerators)
     : options_(options.value_or(Options())),
       vectorFuzzer_(vectorFuzzer),
       state_{rng_, std::max(1, options_.maxLevelOfNesting)},
-      argGenerators_(argGenerators),
-      funcArgOverrides_{argsOverrideFuncs} {
+      argTypesGenerators_(argTypesGenerators),
+      argValuesGenerators_(argValuesGenerators) {
   VELOX_CHECK(vectorFuzzer, "Vector fuzzer must be provided");
   seed(initialSeed);
 
@@ -843,20 +843,20 @@ core::TypedExprPtr ExpressionFuzzer::generateExpression(
 std::vector<core::TypedExprPtr> ExpressionFuzzer::getArgsForCallable(
     const CallableSignature& callable) {
   // Special case for switch because it has a variable number of arguments not
-  // specified in the signature. Other functions' argument override should be
-  // specified through funcArgOverrides_.
+  // specified in the signature. Other functions' argument generators should be
+  // specified through argValuesGenerators_.
   if (callable.name == "switch") {
     return generateSwitchArgs(callable);
   }
 
-  auto funcIt = funcArgOverrides_.find(callable.name);
-  if (funcIt == funcArgOverrides_.end()) {
+  auto funcIt = argValuesGenerators_.find(callable.name);
+  if (funcIt == argValuesGenerators_.end()) {
     return generateArgs(callable);
   }
   auto args = funcIt->second->generate(
       callable, vectorFuzzer_->getOptions(), rng_, state_);
   for (auto i = 0; i < args.size(); ++i) {
-    // Generate arguments not specified in the override.
+    // Generate arguments not specified in the generator.
     if (args[i] == nullptr) {
       args[i] = generateArg(callable.args.at(i), callable.constantArgs.at(i));
     }
@@ -1041,11 +1041,11 @@ core::TypedExprPtr ExpressionFuzzer::generateExpressionFromSignatureTemplate(
     // Use the argument fuzzer to generate argument types.
     argumentTypes = fuzzer.argumentTypes();
   } else {
-    auto it = argGenerators_.find(functionName);
+    auto it = argTypesGenerators_.find(functionName);
     // Since the argument type fuzzer cannot produce argument types, argument
     // generators should be provided.
     VELOX_CHECK(
-        it != argGenerators_.end(),
+        it != argTypesGenerators_.end(),
         "Cannot generate argument types for {} with return type {}.",
         functionName,
         returnType->toString());
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.h b/velox/expression/fuzzer/ExpressionFuzzer.h
index 704d081b59ab..8b8350ff7093 100644
--- a/velox/expression/fuzzer/ExpressionFuzzer.h
+++ b/velox/expression/fuzzer/ExpressionFuzzer.h
@@ -19,7 +19,7 @@
 #include "velox/core/ITypedExpr.h"
 #include "velox/exec/fuzzer/ExprTransformer.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 #include "velox/expression/fuzzer/FuzzerToolkit.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -117,11 +117,11 @@ class ExpressionFuzzer {
       size_t initialSeed,
       const std::shared_ptr<VectorFuzzer>& vectorFuzzer,
       const std::optional<ExpressionFuzzer::Options>& options = std::nullopt,
-      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-          argGenerators = {},
+      const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+          argTypesGenerators = {},
       const std::unordered_map<
           std::string,
-          std::shared_ptr<ArgValuesGenerator>>& argsOverrideFuncs = {});
+          std::shared_ptr<ArgValuesGenerator>>& argValuesGenerators = {});
 
   struct FuzzedExpressionData {
     // A list of generated expressions.
@@ -343,7 +343,8 @@ class ExpressionFuzzer {
   State state_;
 
   // Maps from function name to a specific generator of argument types.
-  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators_;
+  std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
+      argTypesGenerators_;
 
   /// We allow the arg generation routine to be specialized for particular
   /// functions. This map stores the mapping between function name and the
@@ -357,7 +358,7 @@ class ExpressionFuzzer {
   /// of arguments in the overridden method. Arguments at indices beyond the
   /// argument size in the input function signature cannot be left unspecified.)
   std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
-      funcArgOverrides_;
+      argValuesGenerators_;
 
   friend class ExpressionFuzzerUnitTest;
 };
diff --git a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
index 33c2e29452a9..36715f6272c3 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
@@ -18,18 +18,18 @@
 #include <unordered_set>
 
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
-#include "velox/expression/fuzzer/ArgGenerator.h"
-#include "velox/expression/fuzzer/ArgsOverrideFunctions.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
+#include "velox/expression/fuzzer/ArgValuesGenerators.h"
 #include "velox/expression/fuzzer/ExpressionFuzzer.h"
 #include "velox/expression/fuzzer/FuzzerRunner.h"
 #include "velox/expression/fuzzer/SpecialFormSignatureGenerator.h"
-#include "velox/functions/prestosql/fuzzer/DivideArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/ModulusArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/SortArrayTransformer.h"
-#include "velox/functions/prestosql/fuzzer/TruncateArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
 DEFINE_int64(
@@ -53,7 +53,7 @@ DEFINE_uint32(
 
 using namespace facebook::velox::exec::test;
 using facebook::velox::exec::test::PrestoQueryRunner;
-using facebook::velox::fuzzer::ArgGenerator;
+using facebook::velox::fuzzer::ArgTypesGenerator;
 using facebook::velox::fuzzer::ArgValuesGenerator;
 using facebook::velox::fuzzer::ExpressionFuzzer;
 using facebook::velox::fuzzer::FuzzerRunner;
@@ -110,15 +110,16 @@ int main(int argc, char** argv) {
   };
   size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
 
-  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators =
-      {{"plus", std::make_shared<PlusMinusArgGenerator>()},
-       {"minus", std::make_shared<PlusMinusArgGenerator>()},
-       {"multiply", std::make_shared<MultiplyArgGenerator>()},
-       {"divide", std::make_shared<DivideArgGenerator>()},
-       {"floor", std::make_shared<FloorAndRoundArgGenerator>()},
-       {"round", std::make_shared<FloorAndRoundArgGenerator>()},
-       {"mod", std::make_shared<ModulusArgGenerator>()},
-       {"truncate", std::make_shared<TruncateArgGenerator>()}};
+  std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
+      argTypesGenerators = {
+          {"plus", std::make_shared<PlusMinusArgTypesGenerator>()},
+          {"minus", std::make_shared<PlusMinusArgTypesGenerator>()},
+          {"multiply", std::make_shared<MultiplyArgTypesGenerator>()},
+          {"divide", std::make_shared<DivideArgTypesGenerator>()},
+          {"floor", std::make_shared<FloorAndRoundArgTypesGenerator>()},
+          {"round", std::make_shared<FloorAndRoundArgTypesGenerator>()},
+          {"mod", std::make_shared<ModulusArgTypesGenerator>()},
+          {"truncate", std::make_shared<TruncateArgTypesGenerator>()}};
 
   std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
       exprTransformers = {
@@ -128,7 +129,7 @@ int main(int argc, char** argv) {
           {"map_values", std::make_shared<SortArrayTransformer>()}};
 
   std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
-      argsOverrideFuncs = {
+      argValuesGenerators = {
           {"json_parse", std::make_shared<JsonParseArgValuesGenerator>()}};
 
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
@@ -148,8 +149,8 @@ int main(int argc, char** argv) {
       exprTransformers,
       {{"session_timezone", "America/Los_Angeles"},
        {"adjust_timestamp_to_session_timezone", "true"}},
-      argGenerators,
-      argsOverrideFuncs,
+      argTypesGenerators,
+      argValuesGenerators,
       referenceQueryRunner,
       std::make_shared<
           facebook::velox::fuzzer::SpecialFormSignatureGenerator>());
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
index aa3a33b14d7e..e3b00b1c07d9 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
@@ -56,10 +56,10 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
     const FunctionSignatureMap& signatureMap,
     size_t initialSeed,
     const ExpressionFuzzerVerifier::Options& options,
-    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-        argGenerators,
+    const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+        argTypesGenerators,
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
-        argsOverrideFuncs)
+        argValuesGenerators)
     : options_(options),
       queryCtx_(core::QueryCtx::create(
           nullptr,
@@ -79,8 +79,8 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
           initialSeed,
           vectorFuzzer_,
           options_.expressionFuzzerOptions,
-          argGenerators,
-          argsOverrideFuncs),
+          argTypesGenerators,
+          argValuesGenerators),
       referenceQueryRunner_{
           options_.expressionFuzzerOptions.referenceQueryRunner} {
   filesystems::registerLocalFileSystem();
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.h b/velox/expression/fuzzer/ExpressionFuzzerVerifier.h
index 90200455def0..d50c08620859 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerVerifier.h
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.h
@@ -54,11 +54,11 @@ class ExpressionFuzzerVerifier {
       const FunctionSignatureMap& signatureMap,
       size_t initialSeed,
       const Options& options,
-      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-          argGenerators,
+      const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+          argTypesGenerators,
       const std::unordered_map<
           std::string,
-          std::shared_ptr<ArgValuesGenerator>>& argsOverrideFuncs);
+          std::shared_ptr<ArgValuesGenerator>>& argValuesGenerators);
 
   // This function starts the test that is performed by the
   // ExpressionFuzzerVerifier which is generating random expressions and
diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
index 69ab97f69758..53e62d8409ef 100644
--- a/velox/expression/fuzzer/FuzzerRunner.cpp
+++ b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -235,10 +235,10 @@ int FuzzerRunner::run(
     const std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>&
         exprTransformers,
     const std::unordered_map<std::string, std::string>& queryConfigs,
-    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-        argGenerators,
+    const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+        argTypesGenerators,
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
-        argsOverrideFuncs,
+        argValuesGenerators,
     std::shared_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner,
     const std::shared_ptr<SpecialFormSignatureGenerator>&
         specialFormSignatureGenerator) {
@@ -247,8 +247,8 @@ int FuzzerRunner::run(
       skipFunctions,
       exprTransformers,
       queryConfigs,
-      argGenerators,
-      argsOverrideFuncs,
+      argTypesGenerators,
+      argValuesGenerators,
       referenceQueryRunner,
       specialFormSignatureGenerator);
   return RUN_ALL_TESTS();
@@ -261,10 +261,10 @@ void FuzzerRunner::runFromGtest(
     const std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>&
         exprTransformers,
     const std::unordered_map<std::string, std::string>& queryConfigs,
-    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-        argGenerators,
+    const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+        argTypesGenerators,
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
-        argsOverrideFuncs,
+        argValuesGenerators,
     std::shared_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner,
     const std::shared_ptr<SpecialFormSignatureGenerator>&
         specialFormSignatureGenerator) {
@@ -278,7 +278,7 @@ void FuzzerRunner::runFromGtest(
   specialFormSignatureGenerator->appendSpecialForms(
       signatures, options.expressionFuzzerOptions.specialForms);
   ExpressionFuzzerVerifier(
-      signatures, seed, options, argGenerators, argsOverrideFuncs)
+      signatures, seed, options, argTypesGenerators, argValuesGenerators)
       .go();
 }
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/FuzzerRunner.h b/velox/expression/fuzzer/FuzzerRunner.h
index f66f2c73380b..5b1c4afbf9cd 100644
--- a/velox/expression/fuzzer/FuzzerRunner.h
+++ b/velox/expression/fuzzer/FuzzerRunner.h
@@ -41,11 +41,11 @@ class FuzzerRunner {
       const std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>&
           exprTransformers,
       const std::unordered_map<std::string, std::string>& queryConfigs,
-      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-          argGenerators,
+      const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+          argTypesGenerators,
       const std::unordered_map<
           std::string,
-          std::shared_ptr<ArgValuesGenerator>>& argsOverrideFuncs,
+          std::shared_ptr<ArgValuesGenerator>>& argValuesGenerators,
       std::shared_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner,
       const std::shared_ptr<SpecialFormSignatureGenerator>& signatureGenerator);
 
@@ -56,11 +56,11 @@ class FuzzerRunner {
       const std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>&
           exprTransformers,
       const std::unordered_map<std::string, std::string>& queryConfigs,
-      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
-          argGenerators,
+      const std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>&
+          argTypesGenerators,
       const std::unordered_map<
           std::string,
-          std::shared_ptr<ArgValuesGenerator>>& argsOverrideFuncs,
+          std::shared_ptr<ArgValuesGenerator>>& argValuesGenerators,
       std::shared_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner,
       const std::shared_ptr<SpecialFormSignatureGenerator>& signatureGenerator);
 };
diff --git a/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
index d9ce3a99ad37..390daadbc7f7 100644
--- a/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
+++ b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
@@ -25,16 +25,16 @@
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/expression/fuzzer/FuzzerRunner.h"
 #include "velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/DivideArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MultiplyArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/UnscaledValueArgTypesGenerator.h"
 #include "velox/functions/sparksql/registration/Register.h"
 
 using namespace facebook::velox::functions::sparksql::fuzzer;
-using facebook::velox::fuzzer::ArgGenerator;
+using facebook::velox::fuzzer::ArgTypesGenerator;
 using facebook::velox::test::ReferenceQueryRunner;
 
 DEFINE_int64(
@@ -81,24 +81,27 @@ int main(int argc, char** argv) {
       {facebook::velox::core::QueryConfig::kSessionTimezone,
        "America/Los_Angeles"}};
 
-  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators =
-      {{"add", std::make_shared<AddSubtractArgGenerator>(true)},
-       {"add_deny_precision_loss",
-        std::make_shared<AddSubtractArgGenerator>(false)},
-       {"subtract", std::make_shared<AddSubtractArgGenerator>(true)},
-       {"subtract_deny_precision_loss",
-        std::make_shared<AddSubtractArgGenerator>(false)},
-       {"multiply", std::make_shared<MultiplyArgGenerator>(true)},
-       {"multiply_deny_precision_loss",
-        std::make_shared<MultiplyArgGenerator>(false)},
-       {"divide", std::make_shared<DivideArgGenerator>(true)},
-       {"divide_deny_precision_loss",
-        std::make_shared<DivideArgGenerator>(false)},
-       {"floor",
-        std::make_shared<
-            facebook::velox::exec::test::FloorAndRoundArgGenerator>()},
-       {"unscaled_value", std::make_shared<UnscaledValueArgGenerator>()},
-       {"make_timestamp", std::make_shared<MakeTimestampArgGenerator>()}};
+  std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
+      argTypesGenerators = {
+          {"add", std::make_shared<AddSubtractArgTypesGenerator>(true)},
+          {"add_deny_precision_loss",
+           std::make_shared<AddSubtractArgTypesGenerator>(false)},
+          {"subtract", std::make_shared<AddSubtractArgTypesGenerator>(true)},
+          {"subtract_deny_precision_loss",
+           std::make_shared<AddSubtractArgTypesGenerator>(false)},
+          {"multiply", std::make_shared<MultiplyArgTypesGenerator>(true)},
+          {"multiply_deny_precision_loss",
+           std::make_shared<MultiplyArgTypesGenerator>(false)},
+          {"divide", std::make_shared<DivideArgTypesGenerator>(true)},
+          {"divide_deny_precision_loss",
+           std::make_shared<DivideArgTypesGenerator>(false)},
+          {"floor",
+           std::make_shared<
+               facebook::velox::exec::test::FloorAndRoundArgTypesGenerator>()},
+          {"unscaled_value",
+           std::make_shared<UnscaledValueArgTypesGenerator>()},
+          {"make_timestamp",
+           std::make_shared<MakeTimestampArgTypesGenerator>()}};
 
   std::shared_ptr<ReferenceQueryRunner> referenceQueryRunner{nullptr};
   return FuzzerRunner::run(
@@ -106,7 +109,7 @@ int main(int argc, char** argv) {
       skipFunctions,
       {{}},
       queryConfigs,
-      argGenerators,
+      argTypesGenerators,
       {{}},
       referenceQueryRunner,
       std::make_shared<
diff --git a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
similarity index 90%
rename from velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp
rename to velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
index 80cf682b6012..65669c017ebe 100644
--- a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp
+++ b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.cpp
@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include "velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h"
+
 #include <gtest/gtest.h>
 #include "velox/expression/SignatureBinder.h"
 
 namespace facebook::velox::fuzzer::test {
 
 void assertReturnType(
-    const std::shared_ptr<ArgGenerator>& generator,
+    const std::shared_ptr<ArgTypesGenerator>& generator,
     const exec::FunctionSignature& signature,
     const TypePtr& returnType) {
   FuzzerGenerator seed{0};
@@ -39,7 +40,7 @@ void assertReturnType(
 }
 
 void assertEmptyArgs(
-    std::shared_ptr<ArgGenerator> generator,
+    std::shared_ptr<ArgTypesGenerator> generator,
     const exec::FunctionSignature& signature,
     const TypePtr& returnType) {
   FuzzerGenerator seed{0};
diff --git a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h
similarity index 87%
rename from velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h
rename to velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h
index 95b8c4d5ab5f..84f19766d043 100644
--- a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h
+++ b/velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 #include "velox/functions/FunctionRegistry.h"
 
 namespace facebook::velox::fuzzer::test {
@@ -23,13 +23,13 @@ namespace facebook::velox::fuzzer::test {
 /// Assert the equivalence between the given return type and the actual type
 /// resolved from generated argument types.
 void assertReturnType(
-    const std::shared_ptr<ArgGenerator>& generator,
+    const std::shared_ptr<ArgTypesGenerator>& generator,
     const exec::FunctionSignature& signature,
     const TypePtr& returnType);
 
 // Assert that no argument types can be generated for the given return type.
 void assertEmptyArgs(
-    std::shared_ptr<ArgGenerator> generator,
+    std::shared_ptr<ArgTypesGenerator> generator,
     const exec::FunctionSignature& signature,
     const TypePtr& returnType);
 
diff --git a/velox/expression/fuzzer/tests/CMakeLists.txt b/velox/expression/fuzzer/tests/CMakeLists.txt
index c87b21e173f5..5763f1d70cf7 100644
--- a/velox/expression/fuzzer/tests/CMakeLists.txt
+++ b/velox/expression/fuzzer/tests/CMakeLists.txt
@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_expression_fuzzer_test_utility ArgGeneratorTestUtils.cpp)
+add_library(velox_expression_fuzzer_test_utility ArgTypesGeneratorTestUtils.cpp)
 target_link_libraries(
   velox_expression_fuzzer_test_utility velox_expression_functions
   velox_function_registry GTest::gtest)
 
 add_executable(
   velox_expression_fuzzer_unit_test
-  ArgumentTypeFuzzerTest.cpp DecimalArgGeneratorTest.cpp
+  ArgumentTypeFuzzerTest.cpp DecimalArgTypesGeneratorTest.cpp
   ExpressionFuzzerUnitTest.cpp)
 
 target_link_libraries(
diff --git a/velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp b/velox/expression/fuzzer/tests/DecimalArgTypesGeneratorTest.cpp
similarity index 80%
rename from velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp
rename to velox/expression/fuzzer/tests/DecimalArgTypesGeneratorTest.cpp
index 3c77253f56dc..34fb2b22f247 100644
--- a/velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp
+++ b/velox/expression/fuzzer/tests/DecimalArgTypesGeneratorTest.cpp
@@ -15,16 +15,16 @@
  */
 
 #include <gtest/gtest.h>
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
-#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
+#include "velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h"
 
 namespace facebook::velox::fuzzer::test {
 
-class DecimalArgGeneratorTest : public testing::Test {
+class DecimalArgTypesGeneratorTest : public testing::Test {
  protected:
-  class UnaryArgGenerator : public DecimalArgGeneratorBase {
+  class UnaryArgTypesGenerator : public DecimalArgTypesGeneratorBase {
    public:
-    UnaryArgGenerator() {
+    UnaryArgTypesGenerator() {
       initialize(1);
     }
 
@@ -36,9 +36,9 @@ class DecimalArgGeneratorTest : public testing::Test {
     }
   };
 
-  class BinaryArgGenerator : public DecimalArgGeneratorBase {
+  class BinaryArgTypesGenerator : public DecimalArgTypesGeneratorBase {
    public:
-    BinaryArgGenerator() {
+    BinaryArgTypesGenerator() {
       initialize(2);
     }
 
@@ -52,7 +52,7 @@ class DecimalArgGeneratorTest : public testing::Test {
   };
 };
 
-TEST_F(DecimalArgGeneratorTest, unary) {
+TEST_F(DecimalArgTypesGeneratorTest, unary) {
   auto signature =
       exec::FunctionSignatureBuilder()
           .integerVariable("scale")
@@ -63,14 +63,14 @@ TEST_F(DecimalArgGeneratorTest, unary) {
           .argumentType("decimal(precision, scale)")
           .build();
 
-  const auto generator = std::make_shared<UnaryArgGenerator>();
+  const auto generator = std::make_shared<UnaryArgTypesGenerator>();
   for (auto returnType : {DECIMAL(10, 2), DECIMAL(38, 18)}) {
     assertReturnType(generator, *signature, returnType);
   }
   assertEmptyArgs(generator, *signature, DECIMAL(38, 20));
 }
 
-TEST_F(DecimalArgGeneratorTest, binary) {
+TEST_F(DecimalArgTypesGeneratorTest, binary) {
   auto signature =
       exec::FunctionSignatureBuilder()
           .integerVariable("a_scale")
@@ -86,7 +86,7 @@ TEST_F(DecimalArgGeneratorTest, binary) {
           .argumentType("decimal(b_precision, b_scale)")
           .build();
 
-  const auto generator = std::make_shared<BinaryArgGenerator>();
+  const auto generator = std::make_shared<BinaryArgTypesGenerator>();
   for (auto returnType :
        {DECIMAL(10, 2), DECIMAL(38, 20), DECIMAL(38, 38), DECIMAL(38, 0)}) {
     assertReturnType(generator, *signature, returnType);
diff --git a/velox/functions/prestosql/fuzzer/DivideArgGenerator.h b/velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h
similarity index 85%
rename from velox/functions/prestosql/fuzzer/DivideArgGenerator.h
rename to velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h
index 2a05d2e71627..45f147a7ae6d 100644
--- a/velox/functions/prestosql/fuzzer/DivideArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 
 namespace facebook::velox::exec::test {
 
-class DivideArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+class DivideArgTypesGenerator : public fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  DivideArgGenerator() {
+  DivideArgTypesGenerator() {
     initialize(2);
   }
 
diff --git a/velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h b/velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h
similarity index 94%
rename from velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h
rename to velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h
index 72cba5ec97f6..0127b1eb0c65 100644
--- a/velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h
@@ -16,11 +16,11 @@
 #pragma once
 
 #include <boost/random/uniform_int_distribution.hpp>
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 
 namespace facebook::velox::exec::test {
 
-class FloorAndRoundArgGenerator : public fuzzer::ArgGenerator {
+class FloorAndRoundArgTypesGenerator : public fuzzer::ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/functions/prestosql/fuzzer/ModulusArgGenerator.h b/velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h
similarity index 84%
rename from velox/functions/prestosql/fuzzer/ModulusArgGenerator.h
rename to velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h
index e29a01044449..9307250e0a57 100644
--- a/velox/functions/prestosql/fuzzer/ModulusArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 
 namespace facebook::velox::exec::test {
 
-class ModulusArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+class ModulusArgTypesGenerator : public fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  ModulusArgGenerator() {
+  ModulusArgTypesGenerator() {
     initialize(2);
   }
 
diff --git a/velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h b/velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h
similarity index 84%
rename from velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h
rename to velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h
index b8bc21be5112..836ab450c621 100644
--- a/velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 
 namespace facebook::velox::exec::test {
 
-class MultiplyArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+class MultiplyArgTypesGenerator : public fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  MultiplyArgGenerator() {
+  MultiplyArgTypesGenerator() {
     initialize(2);
   }
 
diff --git a/velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h b/velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h
similarity index 84%
rename from velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h
rename to velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h
index 12d166b6a055..716fc8b33c9e 100644
--- a/velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 
 namespace facebook::velox::exec::test {
 
-class PlusMinusArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+class PlusMinusArgTypesGenerator : public fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  PlusMinusArgGenerator() {
+  PlusMinusArgTypesGenerator() {
     initialize(2);
   }
 
diff --git a/velox/functions/prestosql/fuzzer/TruncateArgGenerator.h b/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
similarity index 93%
rename from velox/functions/prestosql/fuzzer/TruncateArgGenerator.h
rename to velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
index 9d413461a9b2..b898e865dd77 100644
--- a/velox/functions/prestosql/fuzzer/TruncateArgGenerator.h
+++ b/velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h
@@ -16,11 +16,11 @@
 #pragma once
 
 #include <boost/random/uniform_01.hpp>
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 
 namespace facebook::velox::exec::test {
 
-class TruncateArgGenerator : public fuzzer::ArgGenerator {
+class TruncateArgTypesGenerator : public fuzzer::ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/functions/prestosql/tests/ArgGeneratorTest.cpp b/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
similarity index 76%
rename from velox/functions/prestosql/tests/ArgGeneratorTest.cpp
rename to velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
index 9d4e496fbc30..1cc8b8e4d0a0 100644
--- a/velox/functions/prestosql/tests/ArgGeneratorTest.cpp
+++ b/velox/functions/prestosql/tests/ArgTypesGeneratorTest.cpp
@@ -13,20 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
-#include "velox/functions/prestosql/fuzzer/DivideArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/ModulusArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h"
-#include "velox/functions/prestosql/fuzzer/TruncateArgGenerator.h"
+#include "velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h"
+#include "velox/functions/prestosql/fuzzer/DivideArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::fuzzer::test;
 namespace {
 
-class ArgGeneratorTest : public functions::test::FunctionBaseTest {
+class ArgTypesGeneratorTest : public functions::test::FunctionBaseTest {
  protected:
   // Returns the only signature with decimal return type for a given function
   // name.
@@ -38,9 +38,10 @@ class ArgGeneratorTest : public functions::test::FunctionBaseTest {
   }
 };
 
-TEST_F(ArgGeneratorTest, plus) {
+TEST_F(ArgTypesGeneratorTest, plus) {
   const auto& signature = getOnlySignature("plus");
-  const auto generator = std::make_shared<exec::test::PlusMinusArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::PlusMinusArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -50,9 +51,10 @@ TEST_F(ArgGeneratorTest, plus) {
   assertEmptyArgs(generator, signature, DECIMAL(18, 18));
 }
 
-TEST_F(ArgGeneratorTest, minus) {
+TEST_F(ArgTypesGeneratorTest, minus) {
   const auto& signature = getOnlySignature("minus");
-  const auto generator = std::make_shared<exec::test::PlusMinusArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::PlusMinusArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -62,9 +64,10 @@ TEST_F(ArgGeneratorTest, minus) {
   assertEmptyArgs(generator, signature, DECIMAL(18, 18));
 }
 
-TEST_F(ArgGeneratorTest, multiply) {
+TEST_F(ArgTypesGeneratorTest, multiply) {
   const auto& signature = getOnlySignature("multiply");
-  const auto generator = std::make_shared<exec::test::MultiplyArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::MultiplyArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(18, 18));
@@ -74,9 +77,10 @@ TEST_F(ArgGeneratorTest, multiply) {
   assertReturnType(generator, signature, DECIMAL(38, 0));
 }
 
-TEST_F(ArgGeneratorTest, divide) {
+TEST_F(ArgTypesGeneratorTest, divide) {
   const auto& signature = getOnlySignature("divide");
-  const auto generator = std::make_shared<exec::test::DivideArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::DivideArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(18, 18));
@@ -86,10 +90,10 @@ TEST_F(ArgGeneratorTest, divide) {
   assertReturnType(generator, signature, DECIMAL(38, 0));
 }
 
-TEST_F(ArgGeneratorTest, floor) {
+TEST_F(ArgTypesGeneratorTest, floor) {
   const auto& signature = getOnlySignature("floor");
   const auto generator =
-      std::make_shared<exec::test::FloorAndRoundArgGenerator>();
+      std::make_shared<exec::test::FloorAndRoundArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 0));
   assertReturnType(generator, signature, DECIMAL(18, 0));
@@ -98,12 +102,12 @@ TEST_F(ArgGeneratorTest, floor) {
   assertEmptyArgs(generator, signature, DECIMAL(10, 2));
 }
 
-TEST_F(ArgGeneratorTest, round) {
+TEST_F(ArgTypesGeneratorTest, round) {
   const auto signatures = getSignatures("round", "decimal");
   VELOX_CHECK_EQ(signatures.size(), 2);
   bool isSingleArg = signatures[0]->argumentTypes().size() == 1;
   const auto generator =
-      std::make_shared<exec::test::FloorAndRoundArgGenerator>();
+      std::make_shared<exec::test::FloorAndRoundArgTypesGenerator>();
 
   const auto& singleArgSignature =
       isSingleArg ? *signatures[0] : *signatures[1];
@@ -123,9 +127,10 @@ TEST_F(ArgGeneratorTest, round) {
   assertEmptyArgs(generator, twoArgsSignature, DECIMAL(1, 0));
 }
 
-TEST_F(ArgGeneratorTest, modulus) {
+TEST_F(ArgTypesGeneratorTest, modulus) {
   const auto& signature = getOnlySignature("mod");
-  const auto generator = std::make_shared<exec::test::ModulusArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::ModulusArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -134,13 +139,14 @@ TEST_F(ArgGeneratorTest, modulus) {
   assertReturnType(generator, signature, DECIMAL(38, 0));
 }
 
-TEST_F(ArgGeneratorTest, truncate) {
+TEST_F(ArgTypesGeneratorTest, truncate) {
   const auto signatures = getSignatures("truncate", "decimal");
   VELOX_CHECK_EQ(signatures.size(), 2);
   const auto& signature = signatures[0]->argumentTypes().size() == 1
       ? *signatures[0]
       : *signatures[1];
-  const auto generator = std::make_shared<exec::test::TruncateArgGenerator>();
+  const auto generator =
+      std::make_shared<exec::test::TruncateArgTypesGenerator>();
 
   assertReturnType(generator, signature, DECIMAL(1, 0));
   assertReturnType(generator, signature, DECIMAL(10, 0));
diff --git a/velox/functions/prestosql/tests/CMakeLists.txt b/velox/functions/prestosql/tests/CMakeLists.txt
index ce0a9304b1f7..a6261a1564f3 100644
--- a/velox/functions/prestosql/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/CMakeLists.txt
@@ -48,7 +48,7 @@ add_executable(
   ArraySumTest.cpp
   ArrayTrimTest.cpp
   ArrayUnionTest.cpp
-  ArgGeneratorTest.cpp
+  ArgTypesGeneratorTest.cpp
   BinaryFunctionsTest.cpp
   BitwiseTest.cpp
   CardinalityTest.cpp
diff --git a/velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h b/velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h
similarity index 86%
rename from velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h
rename to velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h
index be37ec56bca8..5f77c8c6276b 100644
--- a/velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h
+++ b/velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h
@@ -15,14 +15,15 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 #include "velox/functions/sparksql/DecimalUtil.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
-class AddSubtractArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+class AddSubtractArgTypesGenerator
+    : public velox::fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  AddSubtractArgGenerator(bool allowPrecisionLoss)
+  AddSubtractArgTypesGenerator(bool allowPrecisionLoss)
       : allowPrecisionLoss_{allowPrecisionLoss} {
     initialize(2);
   }
diff --git a/velox/functions/sparksql/fuzzer/DivideArgGenerator.h b/velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h
similarity index 88%
rename from velox/functions/sparksql/fuzzer/DivideArgGenerator.h
rename to velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h
index e44ab49746e0..e3023b3cfb4b 100644
--- a/velox/functions/sparksql/fuzzer/DivideArgGenerator.h
+++ b/velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h
@@ -15,14 +15,15 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 #include "velox/functions/sparksql/DecimalUtil.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
-class DivideArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+class DivideArgTypesGenerator
+    : public velox::fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  DivideArgGenerator(bool allowPrecisionLoss)
+  DivideArgTypesGenerator(bool allowPrecisionLoss)
       : allowPrecisionLoss_{allowPrecisionLoss} {
     initialize(2);
   }
diff --git a/velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h b/velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h
similarity index 91%
rename from velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h
rename to velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h
index 5ff9c36888a5..e8595ad7b9f3 100644
--- a/velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h
+++ b/velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h
@@ -16,12 +16,12 @@
 #pragma once
 
 #include <boost/random/uniform_int_distribution.hpp>
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 #include "velox/functions/sparksql/DecimalUtil.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
-class MakeTimestampArgGenerator : public velox::fuzzer::ArgGenerator {
+class MakeTimestampArgTypesGenerator : public velox::fuzzer::ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h b/velox/functions/sparksql/fuzzer/MultiplyArgTypesGenerator.h
similarity index 86%
rename from velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h
rename to velox/functions/sparksql/fuzzer/MultiplyArgTypesGenerator.h
index ac45b0a491db..022398941ead 100644
--- a/velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h
+++ b/velox/functions/sparksql/fuzzer/MultiplyArgTypesGenerator.h
@@ -15,14 +15,15 @@
  */
 #pragma once
 
-#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/DecimalArgTypesGeneratorBase.h"
 #include "velox/functions/sparksql/DecimalUtil.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
-class MultiplyArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+class MultiplyArgTypesGenerator
+    : public velox::fuzzer::DecimalArgTypesGeneratorBase {
  public:
-  MultiplyArgGenerator(bool allowPrecisionLoss)
+  MultiplyArgTypesGenerator(bool allowPrecisionLoss)
       : allowPrecisionLoss_{allowPrecisionLoss} {
     initialize(2);
   }
diff --git a/velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h b/velox/functions/sparksql/fuzzer/UnscaledValueArgTypesGenerator.h
similarity index 90%
rename from velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h
rename to velox/functions/sparksql/fuzzer/UnscaledValueArgTypesGenerator.h
index e60b8fe98597..4937beb699d4 100644
--- a/velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h
+++ b/velox/functions/sparksql/fuzzer/UnscaledValueArgTypesGenerator.h
@@ -16,12 +16,12 @@
 #pragma once
 
 #include <boost/random/uniform_int_distribution.hpp>
-#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/ArgTypesGenerator.h"
 #include "velox/functions/sparksql/DecimalUtil.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
-class UnscaledValueArgGenerator : public velox::fuzzer::ArgGenerator {
+class UnscaledValueArgTypesGenerator : public velox::fuzzer::ArgTypesGenerator {
  public:
   std::vector<TypePtr> generateArgs(
       const exec::FunctionSignature& signature,
diff --git a/velox/functions/sparksql/tests/ArgGeneratorTest.cpp b/velox/functions/sparksql/tests/ArgTypesGeneratorTest.cpp
similarity index 78%
rename from velox/functions/sparksql/tests/ArgGeneratorTest.cpp
rename to velox/functions/sparksql/tests/ArgTypesGeneratorTest.cpp
index 286474bd9337..c93a29cd0303 100644
--- a/velox/functions/sparksql/tests/ArgGeneratorTest.cpp
+++ b/velox/functions/sparksql/tests/ArgTypesGeneratorTest.cpp
@@ -13,24 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include "velox/expression/fuzzer/tests/ArgTypesGeneratorTestUtils.h"
 #include "velox/functions/FunctionRegistry.h"
-#include "velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/DivideArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h"
-#include "velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/AddSubtractArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/DivideArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MakeTimestampArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MultiplyArgTypesGenerator.h"
+#include "velox/functions/sparksql/fuzzer/UnscaledValueArgTypesGenerator.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 using namespace facebook::velox::fuzzer::test;
 namespace facebook::velox::functions::sparksql::test {
 namespace {
 
-class ArgGeneratorTest : public SparkFunctionBaseTest {
+class ArgTypesGeneratorTest : public SparkFunctionBaseTest {
  protected:
   // Assert that the generated argument types meet user-specified check.
   void assertArgumentTypes(
-      std::shared_ptr<velox::fuzzer::ArgGenerator> generator,
+      std::shared_ptr<velox::fuzzer::ArgTypesGenerator> generator,
       const exec::FunctionSignature& signature,
       const TypePtr& returnType,
       std::function<void(const std::vector<TypePtr>&)> check) {
@@ -52,10 +52,10 @@ class ArgGeneratorTest : public SparkFunctionBaseTest {
   }
 };
 
-TEST_F(ArgGeneratorTest, add) {
+TEST_F(ArgTypesGeneratorTest, add) {
   const auto& signature = getOnlySignature("add");
   const auto generator =
-      std::make_shared<fuzzer::AddSubtractArgGenerator>(true);
+      std::make_shared<fuzzer::AddSubtractArgTypesGenerator>(true);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -65,10 +65,10 @@ TEST_F(ArgGeneratorTest, add) {
   assertEmptyArgs(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, addDenyPrecisionLoss) {
+TEST_F(ArgTypesGeneratorTest, addDenyPrecisionLoss) {
   const auto& signature = getOnlySignature("add_deny_precision_loss");
   const auto generator =
-      std::make_shared<fuzzer::AddSubtractArgGenerator>(false);
+      std::make_shared<fuzzer::AddSubtractArgTypesGenerator>(false);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -78,10 +78,10 @@ TEST_F(ArgGeneratorTest, addDenyPrecisionLoss) {
   assertReturnType(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, subtract) {
+TEST_F(ArgTypesGeneratorTest, subtract) {
   const auto& signature = getOnlySignature("subtract");
   const auto generator =
-      std::make_shared<fuzzer::AddSubtractArgGenerator>(true);
+      std::make_shared<fuzzer::AddSubtractArgTypesGenerator>(true);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -91,10 +91,10 @@ TEST_F(ArgGeneratorTest, subtract) {
   assertEmptyArgs(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, subtractDenyPrecisionLoss) {
+TEST_F(ArgTypesGeneratorTest, subtractDenyPrecisionLoss) {
   const auto& signature = getOnlySignature("subtract_deny_precision_loss");
   const auto generator =
-      std::make_shared<fuzzer::AddSubtractArgGenerator>(false);
+      std::make_shared<fuzzer::AddSubtractArgTypesGenerator>(false);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -104,9 +104,10 @@ TEST_F(ArgGeneratorTest, subtractDenyPrecisionLoss) {
   assertReturnType(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, multiply) {
+TEST_F(ArgTypesGeneratorTest, multiply) {
   const auto& signature = getOnlySignature("multiply");
-  const auto generator = std::make_shared<fuzzer::MultiplyArgGenerator>(true);
+  const auto generator =
+      std::make_shared<fuzzer::MultiplyArgTypesGenerator>(true);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -116,9 +117,10 @@ TEST_F(ArgGeneratorTest, multiply) {
   assertEmptyArgs(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, multiplyDenyPrecisionLoss) {
+TEST_F(ArgTypesGeneratorTest, multiplyDenyPrecisionLoss) {
   const auto& signature = getOnlySignature("multiply_deny_precision_loss");
-  const auto generator = std::make_shared<fuzzer::MultiplyArgGenerator>(false);
+  const auto generator =
+      std::make_shared<fuzzer::MultiplyArgTypesGenerator>(false);
 
   assertReturnType(generator, signature, DECIMAL(10, 2));
   assertReturnType(generator, signature, DECIMAL(32, 6));
@@ -128,9 +130,10 @@ TEST_F(ArgGeneratorTest, multiplyDenyPrecisionLoss) {
   assertReturnType(generator, signature, DECIMAL(38, 38));
 }
 
-TEST_F(ArgGeneratorTest, divide) {
+TEST_F(ArgTypesGeneratorTest, divide) {
   const auto& signature = getOnlySignature("divide");
-  const auto generator = std::make_shared<fuzzer::DivideArgGenerator>(true);
+  const auto generator =
+      std::make_shared<fuzzer::DivideArgTypesGenerator>(true);
 
   assertReturnType(generator, signature, DECIMAL(32, 6));
   assertReturnType(generator, signature, DECIMAL(38, 20));
@@ -140,9 +143,10 @@ TEST_F(ArgGeneratorTest, divide) {
   assertEmptyArgs(generator, signature, DECIMAL(10, 2));
 }
 
-TEST_F(ArgGeneratorTest, divideDenyPrecisionLoss) {
+TEST_F(ArgTypesGeneratorTest, divideDenyPrecisionLoss) {
   const auto& signature = getOnlySignature("divide_deny_precision_loss");
-  const auto generator = std::make_shared<fuzzer::DivideArgGenerator>(false);
+  const auto generator =
+      std::make_shared<fuzzer::DivideArgTypesGenerator>(false);
 
   assertReturnType(generator, signature, DECIMAL(32, 6));
   assertReturnType(generator, signature, DECIMAL(38, 20));
@@ -152,11 +156,12 @@ TEST_F(ArgGeneratorTest, divideDenyPrecisionLoss) {
   assertEmptyArgs(generator, signature, DECIMAL(10, 2));
 }
 
-TEST_F(ArgGeneratorTest, makeTimestamp) {
+TEST_F(ArgTypesGeneratorTest, makeTimestamp) {
   const auto signatures = getSignatures("make_timestamp", "timestamp");
   VELOX_CHECK_EQ(signatures.size(), 2);
   bool isSixArgs = signatures[0]->argumentTypes().size() == 6;
-  const auto generator = std::make_shared<fuzzer::MakeTimestampArgGenerator>();
+  const auto generator =
+      std::make_shared<fuzzer::MakeTimestampArgTypesGenerator>();
 
   std::function<void(const TypePtr&)> assertDecimalType =
       [](const TypePtr& type) {
@@ -188,9 +193,10 @@ TEST_F(ArgGeneratorTest, makeTimestamp) {
       });
 }
 
-TEST_F(ArgGeneratorTest, unscaledValue) {
+TEST_F(ArgTypesGeneratorTest, unscaledValue) {
   const auto& signature = getOnlySignature("unscaled_value", "bigint");
-  const auto generator = std::make_shared<fuzzer::UnscaledValueArgGenerator>();
+  const auto generator =
+      std::make_shared<fuzzer::UnscaledValueArgTypesGenerator>();
 
   assertReturnType(generator, signature, BIGINT());
   assertArgumentTypes(
diff --git a/velox/functions/sparksql/tests/CMakeLists.txt b/velox/functions/sparksql/tests/CMakeLists.txt
index 39087bd8adb5..57fdcbf8253e 100644
--- a/velox/functions/sparksql/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/tests/CMakeLists.txt
@@ -22,7 +22,7 @@ add_executable(
   ArrayMinTest.cpp
   ArraySortTest.cpp
   ArrayShuffleTest.cpp
-  ArgGeneratorTest.cpp
+  ArgTypesGeneratorTest.cpp
   AtLeastNNonNullsTest.cpp
   BitwiseTest.cpp
   ComparisonsTest.cpp