fix(volo-build): use absolute path for option (#552)

* fix(volo-build): use absolute path for option

Signed-off-by: Millione <[email protected]>

* fix clippy

Signed-off-by: Millione <[email protected]>

---------

Signed-off-by: Millione <[email protected]>

Author: Millione

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "volo-build"
-version = "0.10.18"
+version = "0.10.19"
 edition.workspace = true
 homepage.workspace = true
 repository.workspace = true

volo-build/Cargo.toml

@@ -474,7 +474,7 @@ impl pilota_build::CodegenBackend for VoloThriftBackend {
                     ty = format!("::std::sync::Arc<{ty}>");
                 }
                 if a.kind == rir::FieldKind::Optional{
-                    ty = format!("Option<{ty}>")
+                    ty = format!("::std::option::Option<{ty}>")
                 };
                 format!(", {name}: {ty}")
             }).join("");
@@ -757,7 +757,7 @@ impl pilota_build::CodegenBackend for VoloThriftBackend {
                 let ty = self.inner.codegen_item_ty(a.ty.kind.clone());
                 let ident = self.cx().rust_name(a.def_id); // use the rust name as string format which will escape the keyword
                 let ty = if a.kind == rir::FieldKind::Optional {
-                    format!("Option<{ty}>")
+                    format!("::std::option::Option<{ty}>")
                 } else {
                     format!("{ty}")
                 };

volo-build/src/thrift_backend.rs

@@ -592,6 +592,60 @@ pub fn detect_protocol<P: AsRef<Path>>(path: P) -> IdlProtocol {
     }
 }
 
+pub(crate) fn write_item(stream: &mut String, base_dir: &Path, name: String, impl_str: String) {
+    let path_buf = base_dir.join(&name);
+    let path = path_buf.as_path();
+    write_file(path, impl_str);
+    stream.push_str(format!("include!(\"{}\");", &name).as_str());
+}
+
+pub(crate) fn write_file(path: &Path, stream: String) {
+    let mut file_writer = std::io::BufWriter::new(std::fs::File::create(path).unwrap());
+    file_writer.write_all(stream.as_bytes()).unwrap();
+    file_writer.flush().unwrap();
+    pilota_build::fmt::fmt_file(path);
+}
+
+pub(crate) fn get_base_dir(mode: &Mode, def_id: Option<&usize>, path: &[Symbol]) -> PathBuf {
+    // Locate directory based on the full item path
+    let base_dir = match mode {
+        // In a workspace mode, the base directory is next to the `.rs` file for the service
+        Mode::Workspace(info) => {
+            let mut dir = info.dir.clone();
+            if path.is_empty() {
+                dir
+            } else {
+                dir.push(path[0].0.as_str());
+                if path.len() > 1 {
+                    dir.push("src");
+                    for segment in path.iter().skip(1) {
+                        dir.push(Path::new(segment.0.as_str()));
+                    }
+                }
+                dir
+            }
+        }
+        // In single file mode, the files directory is the root
+        // The base directory path is the root + the item path
+        Mode::SingleFile { file_path } => {
+            let mut dir = file_path.clone();
+            dir.pop();
+            for segment in path {
+                dir.push(Path::new(segment.0.as_str()));
+            }
+            dir
+        }
+    };
+
+    let base_dir = if let Some(suffix) = def_id {
+        format!("{}_{suffix}", base_dir.display())
+    } else {
+        base_dir.display().to_string()
+    };
+    let base_dir = Path::new(&base_dir);
+    base_dir.to_path_buf()
+}
+
 #[cfg(test)]
 mod tests {
     use std::fs;
@@ -859,57 +913,3 @@ mod tests {
         );
     }
 }
-
-pub(crate) fn write_item(stream: &mut String, base_dir: &Path, name: String, impl_str: String) {
-    let path_buf = base_dir.join(&name);
-    let path = path_buf.as_path();
-    write_file(path, impl_str);
-    stream.push_str(format!("include!(\"{}\");", &name).as_str());
-}
-
-pub(crate) fn write_file(path: &Path, stream: String) {
-    let mut file_writer = std::io::BufWriter::new(std::fs::File::create(path).unwrap());
-    file_writer.write_all(stream.as_bytes()).unwrap();
-    file_writer.flush().unwrap();
-    pilota_build::fmt::fmt_file(path);
-}
-
-pub(crate) fn get_base_dir(mode: &Mode, def_id: Option<&usize>, path: &[Symbol]) -> PathBuf {
-    // Locate directory based on the full item path
-    let base_dir = match mode {
-        // In a workspace mode, the base directory is next to the `.rs` file for the service
-        Mode::Workspace(info) => {
-            let mut dir = info.dir.clone();
-            if path.is_empty() {
-                dir
-            } else {
-                dir.push(path[0].0.as_str());
-                if path.len() > 1 {
-                    dir.push("src");
-                    for segment in path.iter().skip(1) {
-                        dir.push(Path::new(segment.0.as_str()));
-                    }
-                }
-                dir
-            }
-        }
-        // In single file mode, the files directory is the root
-        // The base directory path is the root + the item path
-        Mode::SingleFile { file_path } => {
-            let mut dir = file_path.clone();
-            dir.pop();
-            for segment in path {
-                dir.push(Path::new(segment.0.as_str()));
-            }
-            dir
-        }
-    };
-
-    let base_dir = if let Some(suffix) = def_id {
-        format!("{}_{suffix}", base_dir.display())
-    } else {
-        base_dir.display().to_string()
-    };
-    let base_dir = Path::new(&base_dir);
-    base_dir.to_path_buf()
-}

volo-build/src/util.rs

@@ -137,6 +137,7 @@ impl CompressionEncoding {
     }
 
     /// Get the value of `grpc-encoding` header. Returns an error if the encoding isn't supported.
+    #[allow(clippy::result_large_err)]
     pub fn from_encoding_header(
         headers: &http::HeaderMap,
         config: &Option<Vec<Self>>,

volo-grpc/src/codec/compression.rs

@@ -116,6 +116,7 @@ impl<T: Message + Default> RecvStream<T> {
         }
     }
 
+    #[allow(clippy::result_large_err)]
     fn decode_chunk(&mut self) -> Result<Option<T>, Status> {
         if let State::Header = self.state {
             // data is not enough to decode header, return and keep reading

volo-grpc/src/codec/decode.rs

@@ -13,6 +13,7 @@ pub trait SendEntryMessage {
     ) -> crate::BoxStream<'static, Result<Frame<Bytes>, crate::Status>>;
 }
 
+#[allow(clippy::result_large_err)]
 pub trait RecvEntryMessage: Sized {
     fn from_body(
         method: Option<&str>,

volo-grpc/src/message.rs

@@ -452,7 +452,7 @@ macro_rules! from_integers {
             let val = AsciiMetadataValue::from(n);
             assert_eq!(val, &n.to_string());
 
-            let n = ::std::$t::MAX;
+            let n = $t::MAX;
             let val = AsciiMetadataValue::from(n);
             assert_eq!(val, &n.to_string());
         }
@@ -771,86 +771,86 @@ fn test_from_shared_base64_encodes() {
 
 #[test]
 fn test_value_eq_value() {
-    type BMV = BinaryMetadataValue;
-    type AMV = AsciiMetadataValue;
+    type Bmv = BinaryMetadataValue;
+    type Amv = AsciiMetadataValue;
 
-    assert_eq!(AMV::from_static("abc"), AMV::from_static("abc"));
-    assert_ne!(AMV::from_static("abc"), AMV::from_static("ABC"));
+    assert_eq!(Amv::from_static("abc"), Amv::from_static("abc"));
+    assert_ne!(Amv::from_static("abc"), Amv::from_static("ABC"));
 
-    assert_eq!(BMV::from_bytes(b"abc"), BMV::from_bytes(b"abc"));
-    assert_ne!(BMV::from_bytes(b"abc"), BMV::from_bytes(b"ABC"));
+    assert_eq!(Bmv::from_bytes(b"abc"), Bmv::from_bytes(b"abc"));
+    assert_ne!(Bmv::from_bytes(b"abc"), Bmv::from_bytes(b"ABC"));
 
     // Padding is ignored.
     assert_eq!(
-        BMV::from_static("SGVsbG8hIQ=="),
-        BMV::from_static("SGVsbG8hIQ")
+        Bmv::from_static("SGVsbG8hIQ=="),
+        Bmv::from_static("SGVsbG8hIQ")
     );
     // Invalid values are all just invalid from this point of view.
     // SAFETY: metadata value is valid here
     unsafe {
         assert_eq!(
-            BMV::from_shared_unchecked(Bytes::from_static(b"..{}")),
-            BMV::from_shared_unchecked(Bytes::from_static(b"{}.."))
+            Bmv::from_shared_unchecked(Bytes::from_static(b"..{}")),
+            Bmv::from_shared_unchecked(Bytes::from_static(b"{}.."))
         );
     }
 }
 
 #[test]
 fn test_value_eq_str() {
-    type BMV = BinaryMetadataValue;
-    type AMV = AsciiMetadataValue;
+    type Bmv = BinaryMetadataValue;
+    type Amv = AsciiMetadataValue;
 
-    assert_eq!(AMV::from_static("abc"), "abc");
-    assert_ne!(AMV::from_static("abc"), "ABC");
-    assert_eq!("abc", AMV::from_static("abc"));
-    assert_ne!("ABC", AMV::from_static("abc"));
+    assert_eq!(Amv::from_static("abc"), "abc");
+    assert_ne!(Amv::from_static("abc"), "ABC");
+    assert_eq!("abc", Amv::from_static("abc"));
+    assert_ne!("ABC", Amv::from_static("abc"));
 
-    assert_eq!(BMV::from_bytes(b"abc"), "abc");
-    assert_ne!(BMV::from_bytes(b"abc"), "ABC");
-    assert_eq!("abc", BMV::from_bytes(b"abc"));
-    assert_ne!("ABC", BMV::from_bytes(b"abc"));
+    assert_eq!(Bmv::from_bytes(b"abc"), "abc");
+    assert_ne!(Bmv::from_bytes(b"abc"), "ABC");
+    assert_eq!("abc", Bmv::from_bytes(b"abc"));
+    assert_ne!("ABC", Bmv::from_bytes(b"abc"));
 
     // Padding is ignored.
-    assert_eq!(BMV::from_static("SGVsbG8hIQ=="), "Hello!!");
-    assert_eq!("Hello!!", BMV::from_static("SGVsbG8hIQ=="));
+    assert_eq!(Bmv::from_static("SGVsbG8hIQ=="), "Hello!!");
+    assert_eq!("Hello!!", Bmv::from_static("SGVsbG8hIQ=="));
 }
 
 #[test]
 fn test_value_eq_bytes() {
-    type BMV = BinaryMetadataValue;
-    type AMV = AsciiMetadataValue;
+    type Bmv = BinaryMetadataValue;
+    type Amv = AsciiMetadataValue;
 
-    assert_eq!(AMV::from_static("abc"), "abc".as_bytes());
-    assert_ne!(AMV::from_static("abc"), "ABC".as_bytes());
-    assert_eq!(*"abc".as_bytes(), AMV::from_static("abc"));
-    assert_ne!(*"ABC".as_bytes(), AMV::from_static("abc"));
+    assert_eq!(Amv::from_static("abc"), "abc".as_bytes());
+    assert_ne!(Amv::from_static("abc"), "ABC".as_bytes());
+    assert_eq!(*"abc".as_bytes(), Amv::from_static("abc"));
+    assert_ne!(*"ABC".as_bytes(), Amv::from_static("abc"));
 
-    assert_eq!(*"abc".as_bytes(), BMV::from_bytes(b"abc"));
-    assert_ne!(*"ABC".as_bytes(), BMV::from_bytes(b"abc"));
+    assert_eq!(*"abc".as_bytes(), Bmv::from_bytes(b"abc"));
+    assert_ne!(*"ABC".as_bytes(), Bmv::from_bytes(b"abc"));
 
     // Padding is ignored.
-    assert_eq!(BMV::from_static("SGVsbG8hIQ=="), "Hello!!".as_bytes());
-    assert_eq!(*"Hello!!".as_bytes(), BMV::from_static("SGVsbG8hIQ=="));
+    assert_eq!(Bmv::from_static("SGVsbG8hIQ=="), "Hello!!".as_bytes());
+    assert_eq!(*"Hello!!".as_bytes(), Bmv::from_static("SGVsbG8hIQ=="));
 }
 
 #[test]
 fn test_ascii_value_hash() {
     use std::collections::hash_map::DefaultHasher;
-    type AMV = AsciiMetadataValue;
+    type Amv = AsciiMetadataValue;
 
-    fn hash(value: AMV) -> u64 {
+    fn hash(value: Amv) -> u64 {
         let mut hasher = DefaultHasher::new();
         value.hash(&mut hasher);
         hasher.finish()
     }
 
-    let value1 = AMV::from_static("abc");
-    let value2 = AMV::from_static("abc");
+    let value1 = Amv::from_static("abc");
+    let value2 = Amv::from_static("abc");
     assert_eq!(value1, value2);
     assert_eq!(hash(value1), hash(value2));
 
-    let value1 = AMV::from_static("abc");
-    let value2 = AMV::from_static("xyz");
+    let value1 = Amv::from_static("abc");
+    let value2 = Amv::from_static("xyz");
 
     assert_ne!(value1, value2);
     assert_ne!(hash(value1), hash(value2));
@@ -859,48 +859,48 @@ fn test_ascii_value_hash() {
 #[test]
 fn test_valid_binary_value_hash() {
     use std::collections::hash_map::DefaultHasher;
-    type BMV = BinaryMetadataValue;
+    type Bmv = BinaryMetadataValue;
 
-    fn hash(value: BMV) -> u64 {
+    fn hash(value: Bmv) -> u64 {
         let mut hasher = DefaultHasher::new();
         value.hash(&mut hasher);
         hasher.finish()
     }
 
-    let value1 = BMV::from_bytes(b"abc");
-    let value2 = BMV::from_bytes(b"abc");
+    let value1 = Bmv::from_bytes(b"abc");
+    let value2 = Bmv::from_bytes(b"abc");
     assert_eq!(value1, value2);
     assert_eq!(hash(value1), hash(value2));
 
-    let value1 = BMV::from_bytes(b"abc");
-    let value2 = BMV::from_bytes(b"xyz");
+    let value1 = Bmv::from_bytes(b"abc");
+    let value2 = Bmv::from_bytes(b"xyz");
     assert_ne!(value1, value2);
     assert_ne!(hash(value1), hash(value2));
 }
 
 #[test]
 fn test_invalid_binary_value_hash() {
     use std::collections::hash_map::DefaultHasher;
-    type BMV = BinaryMetadataValue;
+    type Bmv = BinaryMetadataValue;
 
-    fn hash(value: BMV) -> u64 {
+    fn hash(value: Bmv) -> u64 {
         let mut hasher = DefaultHasher::new();
         value.hash(&mut hasher);
         hasher.finish()
     }
 
     // SAFETY: metadata value is valid here
     unsafe {
-        let value1 = BMV::from_shared_unchecked(Bytes::from_static(b"..{}"));
-        let value2 = BMV::from_shared_unchecked(Bytes::from_static(b"{}.."));
+        let value1 = Bmv::from_shared_unchecked(Bytes::from_static(b"..{}"));
+        let value2 = Bmv::from_shared_unchecked(Bytes::from_static(b"{}.."));
         assert_eq!(value1, value2);
         assert_eq!(hash(value1), hash(value2));
     }
 
     // SAFETY: metadata value is valid here
     unsafe {
-        let valid = BMV::from_bytes(b"abc");
-        let invalid = BMV::from_shared_unchecked(Bytes::from_static(b"{}.."));
+        let valid = Bmv::from_bytes(b"abc");
+        let invalid = Bmv::from_shared_unchecked(Bytes::from_static(b"{}.."));
         assert_ne!(valid, invalid);
         assert_ne!(hash(valid), hash(invalid));
     }

volo-grpc/src/metadata/value.rs

@@ -482,6 +482,7 @@ impl Status {
     }
 
     /// Take the `Status` value from `trailers' if it is available, else from 'status_code'.
+    #[allow(clippy::result_large_err)]
     pub fn infer_grpc_status(
         trailers: Option<&HeaderMap>,
         status_code: http::StatusCode,
@@ -548,13 +549,15 @@ impl Status {
     }
 
     /// Convert to HeaderMap
+    #[allow(clippy::result_large_err)]
     pub fn to_header_map(&self) -> Result<HeaderMap, Self> {
         let mut header_map = HeaderMap::with_capacity(3 + self.metadata.len());
         self.add_header(&mut header_map)?;
         Ok(header_map)
     }
 
     /// Insert the associated code, message, and binary details field into the `HeaderMap`.
+    #[allow(clippy::result_large_err)]
     pub(crate) fn add_header(&self, header_map: &mut HeaderMap) -> Result<(), Self> {
         header_map.extend(self.metadata.clone().into_sanitized_headers());