n = ir.NewConstExpr(n.Val(), n)
			break
		}
		n = ir.NewConstExpr(v, n)
		n.SetType(t)
		return n

	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
		ot := operandType(n.Op(), t)
		if ot == nil {
			n = DefaultLit(n, nil)
			break
		}

		n := n.(*ir.UnaryExpr)
		n.X = convlit(n.X, ot)
		if n.X.Type() == nil {
			n.SetType(nil)
			return n
		}

  if (!reshape_op) return false;
  auto operand_type =
      mlir::dyn_cast<RankedTensorType>(reshape_op.getOperand().getType());
  if (!operand_type || !operand_type.hasStaticShape()) return false;
  auto reshape_type = mlir::cast<RankedTensorType>(reshape_op.getType());

  // Reshape can take a 1-D iota input and add extra dims of size one.
  if (operand_type.getRank() != 1) return false;

      ShapedType operand_type = mlir::cast<ShapedType>(operands[0].getType());
      ShapedType indices_type = mlir::cast<ShapedType>(indices.getType());
      ShapedType updates_type = mlir::cast<ShapedType>(updates[0].getType());

      Value new_updates = updates[0];

      // Can only convert with static shaped scatter.
      if (!operand_type.hasStaticShape() || !indices_type.hasStaticShape() ||

        return op->emitOpError()
               << "requires all return types to have compatible element types";
    }
    for (auto operand_type : op->getOperandTypes()) {
      if (!mlir::tf_type::HasCompatibleElementTypes(
              operand_type, type, /*may_ignore_ref_type_lhs=*/true))
        return op->emitError() << "requires all operands and results to have "

  for (auto operand_type_and_idx : llvm::enumerate(op.getOperandTypes())) {
    Type operand_type = operand_type_and_idx.value();
    int index = operand_type_and_idx.index();
    tensorflow::tpu::TPUCompileMetadataProto::Arg* arg = metadata->add_args();
    tensorflow::DataType dtype;
    tensorflow::Status status =
        tensorflow::ConvertToDataType(operand_type, &dtype);
    if (!status.ok())
      return op.emitOpError(

      transpose_dimensions.push_back(s);
      transpose_shape.push_back(operand_type.getShape()[s]);
    }
    for (int64_t i = 0, e = operand_type.getRank(); i < e; ++i) {
      if (llvm::count(start_index_map, i) == 0) {
        transpose_dimensions.push_back(i);
        transpose_shape.push_back(operand_type.getShape()[i]);
      }
    }
    operand_type =

    Value input = op.getOperand();
    TensorType operand_type = input.getType().cast<TensorType>();
    ArrayRef<int64_t> operand_shape = operand_type.getShape();
    const int64_t rank = operand_type.getRank();
    const Type i64_type = rewriter.getI64Type();

    ArrayRef<int64_t> slice_sizes = op.getSliceSizes();
    TensorType single_element_type =
        operand_type.cloneWith({static_cast<int64_t>(1)}, i64_type);

    // one will be garbage collected later.
    if (!mlir::isa<ShapedType>(operand.getType())) return failure();
    auto operand_type = mlir::cast<ShapedType>(operand.getType());
    if (operand_type.getElementType().isInteger(1)) {
      // TF does not support min or max on boolean (int1) arguments.
      // Use AnyOp for MaxOp and AllOp for MinOp.

      mlir::isa<tf_type::TensorFlowRefType>(output_tensor_ty.getElementType());
  for (Type operand_type : merge.getOperandTypes()) {
    if (mlir::isa<ControlType>(operand_type)) break;

    // TODO(hinsu): Update ControlOperandsAfterAllData trait to verify this
    // constraint.
    TensorType operand_tensor_ty = mlir::dyn_cast<TensorType>(operand_type);
    if (!operand_tensor_ty)
      return merge.emitOpError()

      // inputs.
      SmallVector<Value, 4> inputs;
      inputs.reserve(op_with_region->getNumOperands());
      for (Value operand : op_with_region->getOperands()) {
        const Type operand_type = operand.getType();
        if (mlir::isa<NoneType>(operand_type)) {
          inputs.push_back(operand);
          continue;
        }

        const Type element_type =
            mlir::cast<TensorType>(operand.getType()).getElementType();