// TFR function call defines the signatures of the TF ops.
//
namespace mlir {
namespace TFR {

namespace {

// This pattern is to rewrite the "tfr.call" op and the "tfr.cast" ops on the
// operands by a TF op with "tfr.cast" ops on the results. The result type of
// the new TF op is an unranked tensor with element type derived.
class RewriteTFRCallOp : public OpRewritePattern<CallOp> {

// CHECK-NEXT:        name: "min_runtime_version",
// CHECK-NEXT:        buffer: 4
// CHECK-NEXT:      } ],
// CHECK-NEXT:      signature_defs: [  ]
// CHECK-NEXT:    }

  %0 = "tfl.cast" (%arg0) : (tensor<4x5xbf16>) -> tensor<4x5xf32> loc("cast1")
  %1 = "tfl.cast" (%0) : (tensor<4x5xf32>) -> tensor<4x5xbf16> loc("cast2")
  func.return %1 : tensor<4x5xbf16>

  func.func @main(
      %arg0: tensor<10xf32>, %arg1: tensor<10xf32>, %arg2: tensor<6xi32>
    ) -> (tensor<10xf32>, tensor<6xi32>) {
    // CHECK: %[[CAST_0:.*]] = "tf.Cast"(%[[ARG_0]]) <{Truncate = false}> : (tensor<10xf32>) -> tensor<10xbf16>
    // CHECK: %[[CAST_1:.*]] = "tf.Cast"(%[[ARG_1]]) <{Truncate = false}> : (tensor<10xf32>) -> tensor<10xbf16>
    // CHECK: %[[RESULT:.*]]:2 = "tf.XlaCallModule"(%[[CAST_0]], %[[CAST_1]], %[[ARG_2]])

      /*effective_hidden_scale_intermediate=*/mlir::TypeAttr());

  // Cast the static shaped lstm result to FuncOp's signature -
  // Ranked but unknown 2nd dimension to support stacking these.
  SmallVector<int64_t, 2> func_output_shape = {1, tensorflow::kTFDynamicSize};
  auto func_result_type = tensorflow::GetTypeFromTFTensorShape(
      func_output_shape,
      mlir::cast<RankedTensorType>(input_.getType()).getElementType());

  CPred<"quant::ReshapableTo1DTensor($0.getType().cast<ShapedType>())">,
  "Checks if the value dims are all ones except the right most dim">;

def ReshapeTo1DTensor : NativeCodeCall<
  "quant::ReshapeTo1DTensor($_builder, $_loc, $0)">;

def HasEqualShape : Constraint<CPred<
  "$0.getType().cast<ShapedType>().hasRank() && "
  "$1.getType().cast<ShapedType>().hasRank() && "

LogicalResult VerifyTensorTypesCompatible(Type t1, Type t2) {
  if (!mlir::isa<TensorType>(t1) || !mlir::isa<TensorType>(t2)) {
    return failure();
  }
  return verifyCompatibleShape(mlir::cast<TensorType>(t1),
                               mlir::cast<TensorType>(t2));
}

LogicalResult GlobalTensorOp::verify() {
  GlobalTensorOp global_tensor = *this;
  if (global_tensor.getValue()) {
    if (failed(VerifyTensorTypesCompatible(

    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-replace-cast-hacks-with-tf-xla-ops";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Replace mixed-type Conv and Matmul cast hacks with TF XLA ops.";
  }

  void runOnOperation() override;
};

// Generates params for the XLA Convolution op.

        ClassImplementationSnapshot currentImplementation = Cast.uncheckedNonnullCast(thisExecution.getImplementation());
        ClassImplementationSnapshot previousImplementation = Cast.uncheckedNonnullCast(lastExecution.getImplementation());
        ImmutableList<ImplementationSnapshot> currentAdditionalImplementations = Cast.uncheckedNonnullCast(thisExecution.getAdditionalImplementations());

 */
package org.gradle.api.internal.attributes;

import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.Usage;
import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.internal.Cast;
import org.gradle.internal.isolation.Isolatable;
import org.gradle.internal.isolation.IsolatableFactory;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

  const auto gemm_style_op_result_type =
      mlir::cast<RankedTensorType>(gemm_style_op_result.getType());
  const ArrayRef<int64_t> gemm_style_shape =
      gemm_style_op_result_type.getShape();

  Type accumulation_quantized_element_type;
  TensorType new_gemm_style_op_result_type;

  const double input_scale =
      mlir::cast<UniformQuantizedType>(getElementTypeOrSelf(input_type))
          .getScale();