return tflite::TensorType_COMPLEX128;
    }
    llvm_unreachable("invalid complex Type in conversion");
  } else if (auto itype = mlir::dyn_cast<mlir::IntegerType>(type)) {
    switch (itype.getWidth()) {
      case 1:
        return tflite::TensorType_BOOL;
      case 4:
        if (itype.isUnsigned())
          llvm_unreachable("invalid unsigned 4bit integer Type in conversion");
        else

void TensorflowMlrtDialect::printType(mlir::Type type,
                                      mlir::DialectAsmPrinter &os) const {
  if (mlir::isa<TFTensorType>(type)) {
    os << "tensor";
    return;
  }

  llvm_unreachable("unexpected tf_mlrt type kind");
}

}  // namespace tf_mlrt
}  // namespace tensorflow

//===----------------------------------------------------------------------===//
// TableGen'd op method definitions

  if (mlir::isa<TFTensorType>(type)) {
    os << "tf_tensor";
    return;
  }

  if (mlir::isa<TFAllocatorType>(type)) {
    os << "tf_allocator";
    return;
  }

  llvm_unreachable("unexpected fallback type kind");
}

}  // namespace fallback
}  // namespace tfrt

//===----------------------------------------------------------------------===//
// TableGen'd op method definitions

    return;
  }

  if (mlir::isa<PromiseType>(type)) {
    os << "promise";
    return;
  }

  if (mlir::isa<AsyncHandleType>(type)) {
    os << "async_handle";
    return;
  }

  llvm_unreachable("unexpected mlrt type kind");
}

}  // namespace compiler

    } else if (complex_element_ty.isF64()) {
      return DenseElementsAttr::get(
          scalar_ty, static_cast<std::complex<double>>(raw_value));
    }
  }
  llvm_unreachable("unsupported type");
}

// Returns true if `value` is compile-time constant and its splat value equals
// to `raw_value`.
template <typename T>
bool IsConstantValueOf(Value value, T raw_value) {

      if (failed(PropagateQuantParams(op, params, new_items, changed))) {
        return failure();
      }
      break;
    }
    default: {
      // TODO(fengliuai): implement the other types.
      llvm_unreachable("no implementation.");
      return failure();
    }
  }
  return success();
}

LogicalResult QuantizeContext::Finalize() {
  MLIRContext *context = func_.getContext();

      new_output_type = QuantizedType::getQuantizedElementType(
                            dequantize_op.getInput().getType())
                            .castFromExpressedType(output_type);
    } else {
      llvm_unreachable("unhandled element type");
    }

    passthrough_op->getResult(0).setType(new_output_type);
    passthrough_op->setOperand(operand_index, dequantize_op.getInput());

  if (type == tflite::TensorType_INT64) {
    return tflite::TensorType_INT64;
  } else if (type == tflite::TensorType_INT32) {
    return tflite::TensorType_INT32;
  }
  llvm_unreachable("invalid type in conversion.");
}

static tflite::Padding ConvertTFL_PaddingAttrForOptionWriter(
    llvm::StringRef str, flatbuffers::FlatBufferBuilder* builder) {
  return llvm::StringSwitch<tflite::Padding>(str)

static Value CreateTFCastOpF32(OpBuilder *builder, Location loc, Value x,
                               BoolAttr truncate) {
  auto x_type = mlir::dyn_cast_or_null<ShapedType>(x.getType());
  if (!x_type) llvm_unreachable("unsupported type");
  Type type = x_type.clone(builder->getF32Type());
  return builder->create<CastOp>(loc, type, x, truncate);
}

// Returns a TF_CastOp to I32. This function is used for CastOps that are

      case ValueConstraint::kRank:
        return "rank";
      case ValueConstraint::kShape:
        return "shape";
      case ValueConstraint::kValue:
        return "value";
      default:
        llvm_unreachable("unknown value constraint");
    }
  };

  os << str(constraint);
  return os;
}

// -------------------------------------------------------------------------- //
// ValuesConstraintSet.