//   code, with possibly overridden names and defaults.
  OpInfo(const OpDef& graph_op_def, const ApiDef& api_def,
         const std::vector<string>& aliases);
  OpInfo(const OpDef& graph_op_def, const ApiDef& api_def);
  string GetOpAttrStruct() const;
  string GetConstructorDecl(StringPiece op_name_prefix,
                            bool include_attr) const;

  string op_name;

  ApiDefMap api_def_map(op_defs);

  string h_file_text, internal_h_file_text;
  // Without ApiDef
  GenerateCcOpFiles(env, op_defs, api_def_map, &h_file_text,
                    &internal_h_file_text);
  ExpectHasSubstr(h_file_text, "class Foo");
  ExpectDoesNotHaveSubstr(internal_h_file_text, "class Foo");

  // With ApiDef
  TF_ASSERT_OK(api_def_map.LoadApiDef(api_def));

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

// An Op.
//
// Essentially, this represents an OpDef and any necessary context (e.g ApiDef).
class OpSpec {
 public:
  static OpSpec Create(const OpDef& op_def, const ApiDef& api_def);

  const string& name() const { return name_; }
  const string& summary() const { return summary_; }
  const string& description() const { return description_; }

#include <string>

#include "absl/container/flat_hash_set.h"

namespace tensorflow {
namespace generator {

OpSpec OpSpec::Create(const OpDef& op_def, const ApiDef& api_def) {
  return OpSpec(op_def, api_def);
}

OpSpec::OpSpec(const OpDef& op_def, const ApiDef& api_def)
    : name_(op_def.name()),
      summary_(api_def.summary()),
      description_(api_def.description()) {
  absl::flat_hash_set<string> inferred_attrs;

        name,
        op_def_src,
        api_def_srcs = [],
        kernel_deps = []):
    """
    Generates fuzzers for several groups of ops.

    For each one we need the corresponding OpDef, ApiDef and KernelDef,
    since they all can contain constraints for the inputs.

    Args:
        name: the name of the fuzz artifact
        op_def_src: op definitions
        api_def_srcs: api definitions

  std::unique_ptr<WritableFile> fuzz_file = nullptr;
  for (const OpDef& op_def : ops.op()) {
    if (std::find(op_names.begin(), op_names.end(), op_def.name()) ==
        op_names.end())
      continue;

    const ApiDef* api_def = api_def_map->GetApiDef(op_def.name());
    if (api_def == nullptr) {
      continue;
    }

    OpInfo op_info(op_def, *api_def, std::vector<string>());
    status.Update(env->NewWritableFile(

  for (const auto& op_name : path_config_.op_names) {
    const OpDef* op_def = nullptr;
    TF_CHECK_OK(OpRegistry::Global()->LookUpOpDef(op_name, &op_def));
    CHECK(op_def != nullptr);  // Crash OK

    const ApiDef* api_def = api_def_map_->GetApiDef(op_name);
    CHECK(api_def != nullptr);  // Crash OK

    operators_.push_back(OpSpec::Create(*op_def, *api_def));
  }
}

}  // namespace generator

```

## Design

### Generator Framework

The generator framework is a loose Model/View/Controller arrangement:

The *Model* classes live in the ***model/*** directory. They are representations
of the `OpDef` and `ApiDef` protos, normalized and resolved.

> _For example, an `OpDef` proto's `ArgDef` members contain a type string, which
> must be dereferenced to an `AttrDef` by name to determine its type. This