// method that it is a 4-D RankedTensorType.
  Value legalizeFilter(PatternRewriter &rewriter, Location loc,
                       Value filter) const {
    // Create a constant op for HWIO to OHWI transpose permutation.
    SmallVector<int, 4> perm = {3, 0, 1, 2};
    auto perm_type = tensorflow::GetTypeFromTFTensorShape(
        {static_cast<int>(perm.size())}, rewriter.getIntegerType(32));
    auto perm_attr =

// Pattern to fuse redundant tanspose op
def FoldDoubleTranspose : Pat<
  (TF_TransposeOp
    (TF_TransposeOp:$transpose_out1 $input, (Arith_ConstantOp:$permutation1 $p1)),
    (Arith_ConstantOp:$permutation2 $p2)),
  (TF_TransposeOp $input,
    (Arith_ConstantOp (RemapPermutation $permutation1, $permutation2))),
  [(HasOneUse $transpose_out1)]>;

// Pattern to fuse trivial reshape op into transpose op
def FoldTrivialReshapeIntoTranspose : Pat<

func.func @transpose_2d(%arg0: tensor<2x3xf32>) -> tensor<3x2xf32> {
  %0 = mhlo.constant dense<[1, 0]> : tensor<2xi64>
  %1 = mhlo.constant dense<[1, 0]> : tensor<2xi64>
  %2 = "mhlo.transpose"(%arg0) <{permutation = dense<[1, 0]> : tensor<2xi64>}> : (tensor<2x3xf32>) -> tensor<3x2xf32>
  func.return %2 : tensor<3x2xf32>
}

// CHECK-LABEL:   func @transpose_3d_int32(

    }
  }];
}

def TF_InvertPermutationOp : TF_Op<"InvertPermutation", [Pure]> {
  let summary = "Computes the inverse permutation of a tensor.";

  let description = [{
This operation computes the inverse of an index permutation. It takes a 1-D
integer tensor `x`, which represents the indices of a zero-based array, and
swaps each value with its index position. In other words, for an output tensor

// blocks are specified using the following format:
// (kind controlvalue succ0 succ1 ...)
// controlvalue must be "nil" or a value expression
// succ* fields must be variables
// For now, the generated successors must be a permutation of the matched successors.

// constant folding
(Trunc16to8  (Const16  [c])) => (Const8   [int8(c)])
(Trunc32to8  (Const32  [c])) => (Const8   [int8(c)])
(Trunc32to16 (Const32  [c])) => (Const16  [int16(c)])

            this.delegate = delegate;
            this.state = state;
            this.elementType = elementType;
        }

        public C getDelegate(boolean forMutation) {
            if (forMutation) {
                state.assertCanMutate();
            }
            return delegate;
        }

        protected void validateElementType(Object o) {
            if (o != null) {

        configurationCache.assertStateLoaded()

        and:
        result.assertTaskOrder(':lib:compileJava', ':util:compileJava', ':compileJava')

        where:
        order << ['lib', 'util'].permutations()
    }

    private static withDevelocityPlugin(TestFile settingsDir) {
        ApplyDevelocityPluginFixture.applyDevelocityPlugin(
            settingsDir.file('settings.gradle')
        )
    }

  /** Non-NPE RuntimeException. */
  public static class FooException extends RuntimeException {
    private static final long serialVersionUID = 1L;
  }

  /**
   * Class for testing all permutations of static/non-static one-argument methods using
   * methodParameter().
   */
  @SuppressWarnings("unused") // used by reflection
  public static class OneArg {