Method generateArgFunction

bolt/expression/fuzzer/ExpressionFuzzer.cpp:916–970

}

core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
  const auto& functionType = arg->asFunction();

  std::vector<TypePtr> args;
  std::vector<std::string> names;
  std::vector<core::TypedExprPtr> inputs;
  args.reserve(arg->size() - 1);
  names.reserve(arg->size() - 1);
  inputs.reserve(arg->size() - 1);

  for (auto i = 0; i < arg->size() - 1; ++i) {
    args.push_back(arg->childAt(i));
    names.push_back(fmt::format("__a{}", i));
    inputs.push_back(std::make_shared<core::FieldAccessTypedExpr>(
        args.back(), names.back()));
  }

  const auto& returnType = functionType.children().back();

  const auto baseType = typeToBaseName(returnType);
  const auto& baseList = typeToExpressionList_[baseType];
  const auto& templateList = typeToExpressionList_[kTypeParameterName];

  std::vector<std::string> eligible;
  for (const auto& functionName : baseList) {
    if (auto* signature =
            findConcreteSignature(args, returnType, functionName)) {
      eligible.push_back(functionName);
    } else if (
        auto* signatureTemplate =
            findSignatureTemplate(args, returnType, baseType, functionName)) {
      eligible.push_back(functionName);
    }
  }

  for (const auto& functionName : templateList) {
    if (auto* signatureTemplate =
            findSignatureTemplate(args, returnType, baseType, functionName)) {
      eligible.push_back(functionName);
    }
  }

  if (eligible.empty()) {
    return std::make_shared<core::LambdaTypedExpr>(
        ROW(std::move(names), std::move(args)),
        generateArgConstant(returnType));
  }

  const auto idx = rand32(0, eligible.size() - 1);
  const auto name = eligible[idx];

  return std::make_shared<core::LambdaTypedExpr>(
      ROW(std::move(names), std::move(args)),
      std::make_shared<core::CallTypedExpr>(returnType, inputs, name));
}

core::TypedExprPtr ExpressionFuzzer::generateArg(
    const TypePtr& arg,