auto ty = mlir::dyn_cast<TensorType>(op.getType());
    if (!ty ||
        !mlir::isa<FloatType, IntegerType, ComplexType>(ty.getElementType()))
      return failure();

    Location loc = op.getLoc();
    Value result = rewriter.create<mhlo::ConstantOp>(loc, op.getValue());
    if (result.getType() != op.getType())
      result = rewriter.create<tensor::CastOp>(loc, op.getType(), result);
    rewriter.replaceOp(op, result);

// matches the expected type otherwise an error should be thrown, but for now
// we're just returning empty vector
template <>
inline std::vector<bool> GetVector(DenseElementsAttr elements) {
  auto type = elements.getType();
  auto elemType = type.getElementType();
  if (elemType.isSignlessInteger(1)) {
    auto vec = llvm::to_vector(
        llvm::map_range(elements.getValues<bool>(),

      for (auto operand : candidate_op->getOperands()) {
        Type operand_type = operand.getType();
        if (mlir::isa<NoneType>(operand_type)) {
          inputs.push_back(operand);
          continue;
        }

        auto ele_type =
            mlir::cast<TensorType>(operand.getType()).getElementType();
        if (auto dq_op =

    if (!mlir::isa<quant::UniformQuantizedType>(
            (getElementTypeOrSelf(op.getOutput().getType()))))
      return failure();

    ElementsAttr input_tensor = qconst_op.getValue();

    assert(perm_tensor.getType().getRank() == 1);
    const int num_dimensions = input_tensor.getShapedType().getRank();
    assert(perm_tensor.getType().getNumElements() == num_dimensions);

    // we have separate ops for them. If only one of them is used then the other
    // 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.

    BuildableType<"$_builder.getType<::mlrt::compiler::FutureType>()"> {
  let description = [{
    `!mlrt.future type` represents a C++ mlrt::Future.
  }];
}

def MlrtPromiseType : DialectType<Mlrt_Dialect,
    CPred<"$_self.isa<::mlrt::compiler::PromiseType>()">, "!mlrt.promise type">,
    BuildableType<"$_builder.getType<::mlrt::compiler::PromiseType>()"> {
  let description = [{

    const size_t idx = shape_offset_idx.index();

    if (failed(verifyCompatibleShape(shape.getType(), offset.getType())))
      return op.emitOpError() << "requires operand and result " << idx
                              << " to have compatible shapes";

    auto ranked_shape = mlir::dyn_cast<RankedTensorType>(shape.getType());
    if (!ranked_shape) continue;

    if (ranked_shape.getRank() != 1)

  const int lhs_rank = mlir::cast<ShapedType>(lhs.getType()).getShape().size();
  const int rhs_rank = mlir::cast<ShapedType>(rhs.getType()).getShape().size();

  const std::string einsum_equation =
      CreateEinsumEquation(dot_dimension_numbers, lhs_rank, rhs_rank);

  return builder.create<TF::EinsumOp>(loc, output.getType(), input_arguments,

  for (OpOperand& operand : op.getOpOperands()) {
    if (mlir::isa<TF::ResourceType>(
            getElementTypeOrSelf(operand.get().getType()))) {
      return op.emitOpError()
             << "found unexpected type " << operand.get().getType()
             << " of operand #" << operand.getOperandNumber()
             << ", resource type operands are expected to have been "

	var sotype int
	switch net {
	case "unix":
		sotype = syscall.SOCK_STREAM
	case "unixgram":
		sotype = syscall.SOCK_DGRAM
	case "unixpacket":
		sotype = syscall.SOCK_SEQPACKET
	default:
		return nil, UnknownNetworkError(net)
	}

	switch mode {
	case "dial":