}
	switch {
	case len(args) > 2:
		b.names = append(b.names, args[1:]...)
		b.ResourceTypes(SplitResourceArgument(args[0])...)
	case len(args) == 2:
		b.names = append(b.names, args[1])
		b.ResourceTypes(SplitResourceArgument(args[0])...)
	case len(args) == 1:
		b.ResourceTypes(SplitResourceArgument(args[0])...)
		if b.labelSelector == nil && allowEmptySelector {

// watchIdentifier identifies group of watches that are similar.
// As described in the "Priority and Fairness" KEP, we consider
// watches similar if they have the same resourceType, namespace
// and name. We ignore selectors as they have to be evaluated
// when processing an even anyway.
//
// TODO: For now we only track the number of watches registered

                                                const Type target,
                                                const int axis) {
  const auto source_type = dyn_cast_or_null<ShapedType>(source.getValue());
  if (!source_type) return {};
  const auto src_ele_type = source_type.getElementType();
  auto qtype = dyn_cast<quant::QuantizedType>(src_ele_type);

  // Reset the quantization dimensions if it is per-axis.

    description: "Deployments with `image: auto` should be targeted for injection."
    template: "%s %s contains `image: auto` but does not match any Istio injection webhook selectors."
    args:
      - name: resourceType
        type: string
      - name: resourceName
        type: string

  - name: "ImageAutoWithoutInjectionError"
    code: IST0147
    level: Error

    type_attrs.push_back(TypeAttr::get(getElementTypeOrSelf(type)));
  }

  auto anonymous_iterator = builder.create<AnonymousIteratorV3Op>(
      reduce_dataset.getLoc(),
      RankedTensorType::get({}, builder.getType<ResourceType>()),
      /*output_types=*/builder.getArrayAttr(type_attrs),
      /*shape_types=*/builder.getArrayAttr(shape_attrs));
  builder.create<MakeIteratorOp>(reduce_dataset.getLoc(),

Value ReadLocalVariable(Value local_var, OpBuilder builder, Location loc) {
  return builder
      .create<TF::ReadVariableOp>(
          loc,
          ArrayRef<Type>{mlir::cast<TF::ResourceType>(
                             getElementTypeOrSelf(local_var.getType()))
                             .getSubtypes()[0]},
          ArrayRef<Value>{local_var})
      .getValue();
}

}

// Helper function to avoid frequent checks for unknown IDs.
const ResourceIdSet& GetResourceUniqueIdsOrUnknown(
    Value value,
    const ResourceAliasAnalysis::Info& alias_analysis) {
  if (!mlir::isa<TF::ResourceType>(getElementTypeOrSelf(value.getType())) ||
      alias_analysis.IsUnknownResource(value)) return UnknownResourceSet();
  return alias_analysis.GetResourceUniqueIds(value);
}

    }
  }
  return true;
}

bool TypeMustBeNonXLA(const Type& type) {
  const Type elem = getElementTypeOrSelf(type);
  return !mlir::isa<TF::ResourceType>(elem) &&
         !tensorflow::TypeValidForXLA(type);
}

// Check if the op cannot be XLA compiled. If the op does not satisfy this
// criteria, then it is possible for the op to be XLA and non-XLA. But this

  if (auto global_tensor = llvm::dyn_cast<GlobalTensorOp>(op)) {
    auto type = mlir::cast<TensorType>(global_tensor.getType());
    return RankedTensorType::get(
        {}, TF::ResourceType::get({type}, type.getContext()));
  }

  if (auto asset = llvm::dyn_cast<AssetOp>(op)) {
    return RankedTensorType::get({}, TF::StringType::get(asset.getContext()));
  }

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.h"

namespace mlir {
namespace {

bool IsResource(Value value) {
  return mlir::isa<TF::ResourceType>(getElementTypeOrSelf(value.getType()));
}

// Checks if a cast op is casting a resource -> resource.
bool IsCastOfResource(Operation &op) {
  auto cast = dyn_cast<TF::CastOp>(op);
  if (!cast) return false;