Method ExpressionFuzzer

bolt/expression/fuzzer/ExpressionFuzzer.cpp:571–756

} // namespace

ExpressionFuzzer::ExpressionFuzzer(
    FunctionSignatureMap signatureMap,
    size_t initialSeed,
    const std::shared_ptr<VectorFuzzer>& vectorFuzzer,
    const std::optional<ExpressionFuzzer::Options>& options)
    : options_(options.value_or(Options())),
      vectorFuzzer_(vectorFuzzer),
      state{rng_, std::max(1, options_.maxLevelOfNesting)} {
  BOLT_CHECK(vectorFuzzer, "Vector fuzzer must be provided");
  seed(initialSeed);

  appendSpecialForms(signatureMap, options_.specialForms);
  filterSignatures(
      signatureMap, options_.useOnlyFunctions, options_.skipFunctions);

  size_t totalFunctions = 0;
  size_t totalFunctionSignatures = 0;
  size_t supportedFunctionSignatures = 0;
  // A local random number generator to be used just in ExpressionFuzzer
  // constructor. We do not use rng_ in this function because code in this
  // function may change rng_ and cause it to mismatch with the seed printed in
  // the log.
  FuzzerGenerator localRng{
      static_cast<FuzzerGenerator::result_type>(initialSeed)};
  // Process each available signature for every function.
  for (const auto& function : signatureMap) {
    ++totalFunctions;
    bool atLeastOneSupported = false;
    for (const auto& signature : function.second) {
      ++totalFunctionSignatures;

      if (!isSupportedSignature(*signature, options_.enableComplexTypes)) {
        continue;
      }
      if (!(signature->variables().empty() || options_.enableComplexTypes)) {
        LOG(WARNING) << "Skipping unsupported signature: " << function.first
                     << signature->toString();
        continue;
      }
      if (signature->variableArity() && !options_.enableVariadicSignatures) {
        LOG(WARNING) << "Skipping variadic function signature: "
                     << function.first << signature->toString();
        continue;
      }

      // Determine a list of concrete argument types that can bind to the
      // signature. For non-parameterized signatures, these argument types will
      // be used to create a callable signature. For parameterized signatures,
      // these argument types are only used to fetch the function instance to
      // get their determinism.
      std::vector<TypePtr> argTypes;
      if (signature->variables().empty()) {
        bool supportedSignature = true;
        for (const auto& arg : signature->argumentTypes()) {
          auto resolvedType = SignatureBinder::tryResolveType(arg, {}, {});
          if (!resolvedType) {
            supportedSignature = false;
            continue;