null, collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());
                for (Node node : nodes) {
                    flattenResult.addNode(node);
                }
                result = flattenResult;
            } else {
                PathModularizationCache cache = new PathModularizationCache(); // TODO: should be project-wide cache.

    }

    public void setWindowSize(final int windowSize) {
        this.windowSize = windowSize;
    }

    public void addTag(final String tag) {
        this.tags.add(tag);
    }

    public void addRole(final String role) {
        this.roles.add(role);
    }

    public void addField(final String field) {
        this.fields.add(field);
    }

    public void addLanguage(final String lang) {

  NodeDef new_in_def = n->def();
  new_in_def.clear_input();
  new_in_def.set_name(GenerateUniqueName(name_set, new_in_def.name()));
  TF_ASSIGN_OR_RETURN(Node * new_in, graph_->AddNode(new_in_def));

  for (const Edge* e : n->in_edges()) {
    if (e->IsControlEdge()) {
      graph_->AddControlEdge(e->src(), new_in);
    } else {
      graph_->AddEdge(e->src(), e->src_output(), new_in, e->dst_input());

                      ConvertTFDialectOpToNodeDef(
                          inst, name, /*ignore_unregistered_attrs=*/false));
  UseOriginalFunctionNames(*node_def);

  TF_ASSIGN_OR_RETURN(Node * node, graph_->AddNode(std::move(*node_def)));
  DCHECK(node != nullptr);
  nodes_[inst] = node;
  return absl::OkStatus();
}

bool IsEntryFunctionArg(BlockArgument arg) {

                      ConvertTFDialectOpToNodeDef(
                          inst, name, /*ignore_unregistered_attrs=*/false));
  UseOriginalFunctionNames(*node_def);

  TF_ASSIGN_OR_RETURN(Node * node, graph_->AddNode(std::move(*node_def)));
  DCHECK(node != nullptr);
  nodes_[inst] = node;
  return absl::OkStatus();
}

bool IsEntryFunctionArg(BlockArgument arg) {

                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .addParameter(typeName(callable.getOwner().getType()), SELF_PARAMETER_NAME)
                .addParameters(parameters)
                .addCode(generateMethodBody(implementation, callable, implementationExtra))
                .returns(typeName(callable.getReturnType().getType()))
                .addAnnotations(getAnnotations(implementationExtra))
                .build();

    builder.Attr("T", dtype);
    builder.Attr("index", arg_index);
    Status s = builder.Finalize(&arg_def);
    if (!s.ok()) return s;

    TF_ASSIGN_OR_RETURN(Node * arg, graph_->AddNode(arg_def));
    src_arg_pairs->push_back({src_node, arg});
    args_.push_back(arg);
  }
  Node* dst_node = edge->dst();
  Node* dst_image = node_images.at(dst_node);
  int dst_slot = edge->dst_input();

	if utilfeature.DefaultFeatureGate.Enabled(features.TopologyAwareHints) {
		nodeInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
			AddFunc: func(_ interface{}) {
				c.addNode()
			},
			UpdateFunc: func(oldObj, newObj interface{}) {
				c.updateNode(oldObj, newObj)
			},
			DeleteFunc: func(_ interface{}) {
				c.deleteNode()
			},
		})

func AddCoverFlags(cmd *base.Command, coverProfileFlag *string) {
	addCover := false
	if cfg.Experiment != nil && cfg.Experiment.CoverageRedesign {
		// New coverage enabled: both build and test commands get
		// coverage flags.
		addCover = true
	} else {
		// New coverage disabled: only test command gets cover flags.
		addCover = coverProfileFlag != nil
	}
	if addCover {
		cmd.Flag.BoolVar(&cfg.BuildCover, "cover", false, "")

  AddNodeAttr(kXlaNumConstantArgsAttr, num_constant_args, &call_node);
  AddNodeAttr(kXlaNumResourceArgsAttr, num_resource_args, &call_node);
  TF_ASSIGN_OR_RETURN(*result, graph->AddNode(call_node));
  return absl::OkStatus();
}

Status MakeXlaCompiledKernel(Graph* graph, const string& callee_name,
                             const string& node_name, Node** result) {