* A factory for {@link CalculatedValue}.
 */
@ServiceScope(Scope.BuildSession.class)
public interface CalculatedValueFactory {
    /**
     * Creates a calculated value that has no dependencies and that does not access any mutable model state.
     */
    <T> CalculatedValue<T> create(DisplayName displayName, Supplier<? extends T> supplier);

    /**
     * A convenience to create a calculated value that has already been produced.
     * <p>

    private boolean externalVariant;
    private boolean isComponentMetadataRuleCachingEnabled;
    private List<String> statusScheme = DEFAULT_STATUS_SCHEME;
    private MutableModuleSources moduleSources;
    private /*Mutable*/AttributeContainerInternal componentLevelAttributes;
    private final AttributesSchemaInternal schema;

    private final VariantMetadataRules variantMetadataRules;

/**
 * Provides efficient access to a property.
 */
interface PropertyDelegate {
    operator fun <T> getValue(receiver: Any?, property: KProperty<*>): T
}


/**
 * Provides efficient access to a mutable dynamic property.
 */
interface MutablePropertyDelegate : PropertyDelegate {
    operator fun <T> setValue(receiver: Any?, property: KProperty<*>, value: T)
}


internal

    /**
     * Returns a copy of this collection, with the given collection replaced with the value returned by the given supplier.
     *
     * This is used to deal with the case where a mutable collection may be added to itself. This is intended to become an error at some point.
     */
    FileCollectionInternal replace(FileCollectionInternal original, Supplier<FileCollectionInternal> supplier);

    /**

	var lbEndpoints []*endpoint.LocalityLbEndpoints

	isPassthrough := subset.GetTrafficPolicy().GetLoadBalancer().GetSimple() == networking.LoadBalancerSettings_PASSTHROUGH
	clusterType := opts.mutable.cluster.GetType()
	if isPassthrough {
		clusterType = cluster.Cluster_ORIGINAL_DST
	}
	if !(isPassthrough || clusterType == cluster.Cluster_EDS) {

    return {};
  }

  GraphOp main_graph_op = GetGraphOpFromFuncOp(main_func_op);

  FetchOp main_fetch_op = main_graph_op.GetFetch();
  const absl::Cleanup erase_main_fetch_op = [main_fetch_op]() mutable {
    main_fetch_op.erase();
  };

  // TODO(b/245473863): Handle when assets are actually used in the body.
  IRMapping mapper = CloneSrcFuncArgumentsToMainFunc(src_func_op, main_func_op);

  // Note that these Value's are in general in different functions.
  DenseMap<Value, ResourceInfo> resource_infos_;
  // The set of regions we already discovered.
  DenseSet<Region*> discovered_;
  // Identifiers about mutable variables.
  // All variables are identified by (device, container, shared_name).
  DenseSet<std::tuple<llvm::StringRef, llvm::StringRef, llvm::StringRef>>
      mutable_variables_;
};

}  // namespace TF

  void print(raw_ostream &os) const;

  // The operation(s) which created the resource value.
  // IR constructs (i.e., GlobalTensorOp) are not const-correct.
  mutable DenseSet<Operation *> ops;
};

struct IsComposite {
  explicit IsComposite(Operation *op = nullptr);
  static IsComposite EntryState(MLIRContext *context);
  static IsComposite EntryState(Value value);

    /**
     * {@inheritDoc}
     */
    @Override
    ModuleComponentIdentifier getId();

    /**
     * Creates a mutable copy of this metadata.
     *
     * Note that this method can be expensive. Often it is more efficient to use a more specialised mutation method such as {@link #withSources(ModuleSources)} rather than this method.
     */

}


private
suspend fun ReadContext.readAttributesUsing(
    attributesFactory: ImmutableAttributesFactory,
    managedFactories: ManagedFactoryRegistry
): AttributeContainerInternal =
    attributesFactory.mutable().apply {
        readCollection {
            val attribute = readAttribute()
            val value = readAttributeValue(managedFactories)
            attribute(attribute, value)
        }
    }


private