[opentitanlib] rename proxy::errors to util::serializable_error

This is not specific to OT-proxy, and this move will make it possible to
move OT proxy to its own crate.

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

sw/host/opentitanlib/BUILD

@@ -122,7 +122,6 @@ rust_library(
         "src/ownership/mod.rs",
         "src/ownership/owner.rs",
         "src/ownership/rescue.rs",
-        "src/proxy/errors.rs",
         "src/proxy/handler.rs",
         "src/proxy/mod.rs",
         "src/proxy/nonblocking_uart.rs",
@@ -189,6 +188,7 @@ rust_library(
         "src/util/rom_detect.rs",
         "src/util/runtime.rs",
         "src/util/serde.rs",
+        "src/util/serializable_error.rs",
         "src/util/status.rs",
         "src/util/testing.rs",
         "src/util/unknown.rs",

sw/host/opentitanlib/src/proxy/handler.rs

@@ -11,7 +11,6 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use super::CommandHandler;
-use super::errors::SerializedError;
 use super::protocol::{
     BitbangEntryRequest, BitbangEntryResponse, DacBangEntryRequest, EmuRequest, EmuResponse,
     GpioBitRequest, GpioBitResponse, GpioDacRequest, GpioDacResponse, GpioMonRequest,
@@ -28,6 +27,7 @@ use crate::io::{i2c, spi};
 use crate::proxy::Connection;
 use crate::proxy::nonblocking_uart::NonblockingUartRegistry;
 use crate::transport::TransportError;
+use crate::util::serializable_error::SerializedError;
 
 /// Implementation of the handling of each protocol request, by means of an underlying
 /// `Transport` implementation.

sw/host/opentitanlib/src/proxy/mod.rs

@@ -12,7 +12,6 @@ use tokio::net::TcpListener;
 
 use crate::app::TransportWrapper;
 
-pub mod errors;
 mod handler;
 mod nonblocking_uart;
 pub mod protocol;

sw/host/opentitanlib/src/proxy/protocol.rs

@@ -13,8 +13,8 @@ use crate::io::gpio::{
 use crate::io::i2c::DeviceStatus;
 use crate::io::spi::{MaxSizes, TransferMode};
 use crate::io::uart::{FlowControl, Parity};
-use crate::proxy::errors::SerializedError;
 use crate::transport::Capabilities;
+use crate::util::serializable_error::SerializedError;
 use crate::util::voltage::Voltage;
 
 #[derive(Serialize, Deserialize)]

sw/host/opentitanlib/src/util/mod.rs

@@ -16,6 +16,7 @@ pub mod raw_tty;
 pub mod rom_detect;
 pub mod runtime;
 pub mod serde;
+pub mod serializable_error;
 pub mod status;
 pub mod testing;
 pub mod unknown;

sw/host/opentitanlib/src/proxy/errors.rs renamed to sw/host/opentitanlib/src/util/serializable_error.rs

@@ -14,7 +14,7 @@ pub struct SerializableErrorRegistration {
 inventory::collect!(SerializableErrorRegistration);
 
 /// `SerializableError` is a trait which represents an error type that can
-/// be sent over the wire by the proxy protocol.
+/// be sent over the wire.
 #[typetag::serde(tag = "error_type")]
 pub trait SerializableError: Serialize + std::error::Error + std::fmt::Debug + Send + Sync {
     fn as_anyhow_error(self: Box<Self>) -> anyhow::Error;
@@ -27,14 +27,14 @@ macro_rules! impl_serializable_error {
     ($t:ty) => {
         const _: () = {
             #[typetag::serde]
-            impl $crate::proxy::errors::SerializableError for $t {
+            impl $crate::util::serializable_error::SerializableError for $t {
                 fn as_anyhow_error(self: Box<$t>) -> anyhow::Error {
                     self.into()
                 }
             }
 
-            $crate::proxy::errors::submit! {
-                $crate::proxy::errors::SerializableErrorRegistration {
+            $crate::util::serializable_error::submit! {
+                $crate::util::serializable_error::SerializableErrorRegistration {
                     try_convert: |err| {
                         if !err.is::<$t>() {
                             return Err(err);
@@ -43,7 +43,7 @@ macro_rules! impl_serializable_error {
                         let description = err.to_string();
                         let backtrace = format!("{:#?}", err.backtrace());
                         let downcast = err.downcast::<$t>().unwrap();
-                        Ok($crate::proxy::errors::SerializedError {
+                        Ok($crate::util::serializable_error::SerializedError {
                             description,
                             backtrace,
                             error: Some(Box::new(downcast)),
@@ -55,7 +55,7 @@ macro_rules! impl_serializable_error {
     };
 }
 
-/// `SerializedError` is the wire form of errors that can be sent through the proxy.
+/// `SerializedError` is the wire form of errors that can be sent through network.
 #[derive(serde::Serialize, serde::Deserialize, Debug)]
 pub struct SerializedError {
     pub description: String,