// expected-error @+1 {{found unexpected type 'tensor<!tf_type.resource<tensor<10x3xf32>>>' of operand #0, resource type operands are expected to have been canonicalized away for region based control flow ops}}
  %1:2 = "tf.WhileRegion"(%ta#0, %size) ({
    ^bb0 (%carg0: tensor<!tf_type.resource>, %carg1: tensor<i32>):
      %pred = "tf._SomeOp"(%carg1) : (tensor<i32>) -> tensor<i1>

        return this.fileLocator.getParent();
    }


    /**
     * Returns the full uncanonicalized URL of this SMB resource. An
     * <code>SmbFile</code> constructed with the result of this method will
     * result in an <code>SmbFile</code> that is equal to the original.
     *
     * @return The uncanonicalized full URL of this SMB resource.
     */

    public String getPath () {

  return success();
}

// Lifts loads/stores from an IfOp or CaseOp's branches.
template <class CaseOrIfOp>
LogicalResult HandleCaseOrIfOp(CaseOrIfOp op, ArrayRef<func::FuncOp> branches) {
  // For canonicalized If/Case, there should not be any resource outputs
  int64_t non_resource_results = op.getNumResults();

  llvm::SmallDenseMap<int64_t, ResourceArgUseInfo> resource_arg_uses;

        }
      }

    fun username(username: String) =
      apply {
        this.encodedUsername = username.canonicalize(encodeSet = USERNAME_ENCODE_SET)
      }

    fun encodedUsername(encodedUsername: String) =
      apply {
        this.encodedUsername =
          encodedUsername.canonicalize(
            encodeSet = USERNAME_ENCODE_SET,
            alreadyEncoded = true,
          )
      }

	name        *ir.Name
	offset      int64
	width       int64
	splitOf     SlKeyIdx // idx in slkeys slice in slotCanonicalizer
	splitOffset int64
}

// lookup looks up a LocalSlot in the slot canonicalizer "sc", returning
// a canonical index for the slot, and adding it to the table if need
// be. Return value is the canonical slot index, and a boolean indicating
// whether the slot was found in the table already (TRUE => found).

                        result.getProblems().add(problem);
                        continue;
                    }

                    if (Os.IS_WINDOWS) {
                        // we don't canonicalize on unix to avoid interfering with symlinks
                        try {
                            moduleFile = moduleFile.getCanonicalFile();
                        } catch (IOException e) {

// Note: this must match If statement lowering.
(CLIJ {s390x.LessOrGreater} (LOCGR {d} (MOVDconst [0]) (MOVDconst [x]) cmp) [0] yes no)
  && int32(x) != 0
  => (BRC {d} cmp yes no)

// Canonicalize BRC condition code mask by removing impossible conditions.
// Integer comparisons cannot generate the unordered condition.

		// the package does not exist.
		// Other errors may affect package loading, but not resolution.
		if _, err := fsys.Stat(absDir); err != nil {
			if os.IsNotExist(err) {
				// Canonicalize OS-specific errors to errDirectoryNotFound so that error
				// messages will be easier for users to search for.
				return "", &fs.PathError{Op: "stat", Path: absDir, Err: errDirectoryNotFound}
			}
			return "", err

_Replace TF BatchMatMul op by TF Einsum op._

### `-tf-broadcast-fold`

_Fold explicit broadcasts into the following operations if they support implicit broadcasting on their operand._

### `-tf-canonicalize-compile-and-replicate-attributes`

_Canonicalize compilation and replication attributes._

A pass that converts existing compilation and replication attributes into
unified attributes. For example, `_tpu_replicate="cluster"` in the
following code

                              int32_t idx, BoolAttr use_32bit) {
  if (auto ranked_ty =
          mlir::dyn_cast_or_null<RankedTensorType>(input.getType())) {
    // Canonicalize negative index.
    if (idx < 0) {
      idx += ranked_ty.getRank();
    }
    // Return a ConstOp if it's static dimension.
    if (!ranked_ty.isDynamicDim(idx)) {
      return builder->create<TF::ConstOp>(