Merge pull request #12 from dfns/udigest_as

Add DigestAs functionality
LFDT-Lockness · Aug 26, 2024 · d9d1414 · d9d1414
2 parents 41423f6 + dc6242f
commit d9d1414
Show file tree

Hide file tree

Showing 14 changed files with 862 additions and 81 deletions.
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -7,6 +7,7 @@ on:
 env:
   CARGO_TERM_COLOR: always
   CARGO_NET_GIT_FETCH_WITH_CLI: true
+  RUSTFLAGS: -D warnings
 
 jobs:
   check-and-test:
@@ -20,9 +21,9 @@ jobs:
       with:
         cache-on-failure: "true"
     - name: Check
-      run: cargo check -p udigest --features "${{ matrix.features }}"
+      run: cargo check -p udigest --no-default-features --features "${{ matrix.features }}"
     - name: Run tests
-      run: cargo test -p udigest --lib --tests --features "${{ matrix.features }}"
+      run: cargo test -p udigest --lib --tests --no-default-features --features "${{ matrix.features }}"
   test-all-features:
     runs-on: ubuntu-latest
     steps:

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/udigest-derive/CHANGELOG.md b/udigest-derive/CHANGELOG.md
@@ -1,3 +1,8 @@
+## v0.3.0
+* Add `#[udigest(as = ...)]` attribute support [#12]
+
+[#12]: https://github.com/dfns/udigest/pull/12
+
 ## v0.2.0
 * Fix proc macro causing clippy warnings in certain cases [#6]
 

diff --git a/udigest-derive/Cargo.toml b/udigest-derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "udigest-derive"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 description = "Proc macro for `udigest` crate"
 license = "MIT OR Apache-2.0"

diff --git a/udigest-derive/src/attrs.rs b/udigest-derive/src/attrs.rs
@@ -18,6 +18,7 @@ pub enum Attr {
     Skip(Skip),
     Rename(Rename),
     With(With),
+    As(As),
 }
 
 impl Attr {
@@ -30,6 +31,7 @@ impl Attr {
             Attr::Skip(attr) => attr.skip.span,
             Attr::Rename(attr) => attr.rename.span,
             Attr::With(attr) => attr.with.span,
+            Attr::As(attr) => attr.as_.span,
         }
     }
 }
@@ -51,6 +53,8 @@ impl syn::parse::Parse for Attr {
             Rename::parse(input).map(Attr::Rename)
         } else if lookahead.peek(kw::with) {
             With::parse(input).map(Attr::With)
+        } else if lookahead.peek(syn::Token![as]) {
+            As::parse(input).map(Attr::As)
         } else {
             Err(lookahead.error())
         }
@@ -59,7 +63,7 @@ impl syn::parse::Parse for Attr {
 
 pub struct Root {
     pub root: kw::root,
-    pub eq: syn::Token![=],
+    pub _eq: syn::Token![=],
     pub path: RootPath,
 }
 
@@ -68,68 +72,68 @@ pub type RootPath = syn::punctuated::Punctuated<syn::Ident, syn::Token![::]>;
 impl syn::parse::Parse for Root {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let root = input.parse::<kw::root>()?;
-        let eq = input.parse::<syn::Token![=]>()?;
+        let _eq = input.parse::<syn::Token![=]>()?;
         let path = RootPath::parse_separated_nonempty_with(input, syn::Ident::parse_any)?;
 
-        Ok(Self { root, eq, path })
+        Ok(Self { root, _eq, path })
     }
 }
 
 pub struct Tag {
     pub tag: kw::tag,
-    pub eq: syn::Token![=],
+    pub _eq: syn::Token![=],
     pub value: syn::Expr,
 }
 
 impl syn::parse::Parse for Tag {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let tag = input.parse()?;
-        let eq = input.parse()?;
+        let _eq = input.parse()?;
         let value = input.parse()?;
 
-        Ok(Self { tag, eq, value })
+        Ok(Self { tag, _eq, value })
     }
 }
 
 pub struct AsBytes {
     pub as_bytes: kw::as_bytes,
-    pub eq: Option<syn::Token![=]>,
+    pub _eq: Option<syn::Token![=]>,
     pub value: Option<syn::Expr>,
 }
 
 impl syn::parse::Parse for AsBytes {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let as_bytes = input.parse()?;
-        let mut eq = None;
+        let mut _eq = None;
         let mut value = None;
 
         let lookahead = input.lookahead1();
         if lookahead.peek(syn::Token![=]) {
-            eq = Some(input.parse()?);
+            _eq = Some(input.parse()?);
             value = Some(input.parse()?);
         }
 
         Ok(Self {
             as_bytes,
-            eq,
+            _eq,
             value,
         })
     }
 }
 
 pub struct Bound {
     pub bound: kw::bound,
-    pub eq: syn::Token![=],
+    pub _eq: syn::Token![=],
     pub value: syn::LitStr,
 }
 
 impl syn::parse::Parse for Bound {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let bound = input.parse()?;
-        let eq = input.parse()?;
+        let _eq = input.parse()?;
         let value = input.parse()?;
 
-        Ok(Self { bound, eq, value })
+        Ok(Self { bound, _eq, value })
     }
 }
 
@@ -146,31 +150,46 @@ impl syn::parse::Parse for Skip {
 
 pub struct Rename {
     pub rename: kw::rename,
-    pub eq: syn::Token![=],
+    pub _eq: syn::Token![=],
     pub value: syn::Expr,
 }
 
 impl syn::parse::Parse for Rename {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let rename = input.parse()?;
-        let eq = input.parse()?;
+        let _eq = input.parse()?;
         let value = input.parse()?;
 
-        Ok(Self { rename, eq, value })
+        Ok(Self { rename, _eq, value })
     }
 }
 
 pub struct With {
     pub with: kw::with,
-    pub eq: syn::Token![=],
+    pub _eq: syn::Token![=],
     pub value: syn::Expr,
 }
 
 impl syn::parse::Parse for With {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let with = input.parse()?;
-        let eq = input.parse()?;
+        let _eq = input.parse()?;
         let value = input.parse()?;
-        Ok(Self { with, eq, value })
+        Ok(Self { with, _eq, value })
+    }
+}
+
+pub struct As {
+    pub as_: syn::Token![as],
+    pub _eq: syn::Token![=],
+    pub value: syn::Type,
+}
+
+impl syn::parse::Parse for As {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let as_ = input.parse()?;
+        let _eq = input.parse()?;
+        let value = input.parse()?;
+        Ok(Self { as_, _eq, value })
     }
 }