rulesByInput = new NodeAtStateIndex("rulesByInput");
    }

    public void nodeCreated(ModelNodeInternal node) {
        untypedPathReferences.addNode(node);
    }

    public void nodeDiscovered(ModelNodeInternal node) {
        typedPathReferences.addNode(node);
        scopeReferences.addNodeToScope(node.getPath(), node);
        scopeReferences.addNodeToScope(node.getPath().getParent(), node);
    }

            << ", type: " << n->type_string();
    // Ignore the status returned by the shape_refiner. We want the best effort
    // shapes, even if no shape function is registered for a node.
    Status status = shape_refiner->AddNode(n);
    if (!status.ok()) {
      VLOG(1) << "Shape inference failed for node " << n->name() << ": "
              << status;
    } else {
      shape_inference::InferenceContext* context = shape_refiner->GetContext(n);

        if (target != null) {
            referenceNode.setTarget(target);
        }
        addNode(referenceNode, registration);
    }

    @Override
    public void addLink(ModelRegistration registration) {
        addNode(new ModelElementNode(modelRegistry, registration, this), registration);
    }

    private void addNode(ModelNodeInternal child, ModelRegistration registration) {
        ModelPath childPath = child.getPath();

            .returns(Object.class)
            .addParameter(INVOCATION_CLASS, "invocation")
            .addParameter(String.class, "consumer")
            .addException(Throwable.class)
            .addCode(generateCodeFromInterceptorSignatureTree(signatureTree))
            .build();

        ParameterizedTypeName classWildcard = ParameterizedTypeName.get(ClassName.get(Class.class), WildcardTypeName.subtypeOf(Object.class));

        VariantGraphResolveState rootVariant = root.getRootVariant();
        this.root = new RootNode(idGenerator.nextGraphNodeId(), rootComponent, this, syntheticDependencies, rootVariant);
        rootComponent.addNode(this.root);
        ComponentVariantNodeIdentifier rootNodeId = new ComponentVariantNodeIdentifier(componentId, rootVariant.getName());
        nodes.put(rootNodeId, this.root);
    }

                      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();

	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()
			},
		})

  // by name), and makes sure the resulting graph is valid.
  Status ToGraph(
      Graph* g, GraphConstructorOptions opts = GraphConstructorOptions{}) const;

  // Calls AddNode() using this scope's ShapeRefiner. This exists in the public
  // API to prevent custom op wrappers from needing access to shape_refiner.h or
  // scope_internal.h.
  // TODO(skyewm): remove this from public API