Ergotree proc-macro

.github/workflows/ci.yml

@@ -57,12 +57,12 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --verbose --release --tests
+          args: --verbose --tests
       - name: Run tests
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --verbose --release
+          args: --verbose
 
   test_coverage:
     name: Code coverage in tests

Cargo.toml

@@ -6,6 +6,7 @@ members = [
     "ergoscript-compiler",
     "ergotree-ir",
     "ergotree-interpreter",
+    "ergotree-macro",
     "ergo-lib",
     "ergo-p2p",
     "ergo-chain-generation",

ergotree-interpreter/Cargo.toml

@@ -62,4 +62,5 @@ ergotree-ir = { version = "^0.20.0", path = "../ergotree-ir", features = ["arbit
 ergoscript-compiler = { version = "^0.16.0", path = "../ergoscript-compiler" }
 proptest = "1.0.0"
 sigma-test-util = { version = "^0.3.0", path = "../sigma-test-util" }
+ergotree-macro = { version = "0.20", path = "../ergotree-macro"}
 

ergotree-ir/Cargo.toml

@@ -39,6 +39,9 @@ strum_macros = "0.21"
 indexmap = "1.3.2"
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0", features = ["arbitrary_precision"], optional = true }
+syn = { version = "1", features = ["parsing"], optional = true }
+quote = { version = "1", optional = true }
+proc-macro2 = { version = "1", optional = true }
 
 [dependencies.proptest]
 # wasm support, via https://altsysrq.github.io/proptest-book/proptest/wasm.html
@@ -59,6 +62,7 @@ optional = true
 default = ["json"]
 arbitrary = ["proptest", "proptest-derive", "ergo-chain-types/arbitrary"]
 json = ["serde", "serde_json", "serde_with", "bounded-vec/serde"]
+ergotree-proc-macro = ["syn", "quote", "proc-macro2"]
 
 [dev-dependencies]
 sigma-test-util = { version = "^0.3.0", path = "../sigma-test-util" }

ergotree-ir/src/ergotree_proc_macro.rs

@@ -0,0 +1,264 @@
+//! Utility code to support `ergo_tree!` procedural-macro
+
+use syn::{ext::IdentExt, Ident};
+
+use crate::types::stype::SType;
+
+/// A representation of the type T extracted from `_.typed[T]` on scala side.
+#[derive(Debug)]
+pub enum ExtractedType {
+    /// Fully specified `SType`
+    FullySpecified(SType),
+    /// `SCollection[_]]` in scala representation.
+    SCollection(Box<ExtractedType>),
+    /// `SOption[_]]` in scala representation.
+    SOption(Box<ExtractedType>),
+    /// `STuple` in scala representation
+    STuple,
+}
+
+impl From<SType> for ExtractedType {
+    fn from(s: SType) -> Self {
+        ExtractedType::FullySpecified(s)
+    }
+}
+
+/// Extracts T within `_.typed[T]`.
+/// Note that scala uses some type aliases: e.g. `BoolValue` is short for `Value[SBoolean.type]`
+pub fn extract_tpe_from_dot_typed(
+    buf: syn::parse::ParseStream,
+) -> Result<ExtractedType, syn::Error> {
+    let ident: syn::Ident = buf.parse()?;
+    match &*ident.to_string() {
+        "BoolValue" => Ok(SType::SBoolean.into()),
+        "IntValue" => Ok(SType::SInt.into()),
+        "ShortValue" => Ok(SType::SShort.into()),
+        "LongValue" => Ok(SType::SLong.into()),
+        "BigIntValue" => Ok(SType::SBigInt.into()),
+        "ByteValue" => Ok(SType::SByte.into()),
+        "SigmaPropValue" => Ok(SType::SSigmaProp.into()),
+        "STuple" => Ok(ExtractedType::STuple),
+        "SByte" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SByte))
+        }
+        "SGroupElement" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SGroupElement))
+        }
+        "SInt" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SInt))
+        }
+        "SLong" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SLong))
+        }
+        "SBigInt" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SBigInt))
+        }
+        "SBoolean" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SBoolean))
+        }
+        "SAvlTree" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SAvlTree))
+        }
+        "SBox" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SBox))
+        }
+        "SSigmaProp" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SSigmaProp))
+        }
+        "SHeader" => {
+            handle_dot_type(buf)?;
+            Ok(ExtractedType::FullySpecified(SType::SHeader))
+        }
+        "SOption" => {
+            let content_nested;
+            let _bracketed = syn::bracketed!(content_nested in buf);
+            Ok(ExtractedType::SOption(Box::new(
+                extract_tpe_from_dot_typed(&content_nested)?,
+            )))
+        }
+        "SCollection" => {
+            let content_nested;
+            let _bracketed = syn::bracketed!(content_nested in buf);
+
+            //let _ident: syn::Ident = content_nested.parse()?;
+            //handle_dot_type(&content_nested)?;
+            Ok(ExtractedType::SCollection(Box::new(
+                extract_tpe_from_dot_typed(&content_nested)?,
+            )))
+        }
+        "Value" => {
+            let content;
+            let _bracketed = syn::bracketed!(content in buf);
+            let next_ident: syn::Ident = content.parse()?;
+            match &*next_ident.to_string() {
+                "STuple" => Ok(ExtractedType::STuple),
+                "SByte" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SByte))
+                }
+                "SGroupElement" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SGroupElement))
+                }
+                "SInt" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SInt))
+                }
+                "SLong" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SLong))
+                }
+                "SBigInt" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SBigInt))
+                }
+                "SBoolean" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SBoolean))
+                }
+                "SAvlTree" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SAvlTree))
+                }
+                "SBox" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SBox))
+                }
+                "SSigmaProp" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SSigmaProp))
+                }
+                "SHeader" => {
+                    handle_dot_type(buf)?;
+                    Ok(ExtractedType::FullySpecified(SType::SHeader))
+                }
+                "SOption" => {
+                    let content_nested;
+                    let _bracketed = syn::bracketed!(content_nested in content);
+                    Ok(ExtractedType::SOption(Box::new(
+                        extract_tpe_from_dot_typed(&content_nested)?,
+                    )))
+                }
+                "SCollection" => {
+                    let content_nested;
+                    let _bracketed = syn::bracketed!(content_nested in content);
+
+                    Ok(ExtractedType::SCollection(Box::new(
+                        extract_tpe_from_dot_typed(&content_nested)?,
+                    )))
+                }
+                t => {
+                    unreachable!("unknown ident T in _.typed[Value[T]]: T = {}", t)
+                }
+            }
+        }
+        t => unreachable!("unknown ident T in _.typed[T]: T = {}", t),
+    }
+}
+
+//pub fn extract_tpe_from_dot_typed(
+//    buf: syn::parse::ParseStream,
+//) -> Result<ExtractedType, syn::Error> {
+//    let ident: syn::Ident = buf.parse()?;
+//    match &*ident.to_string() {
+//        "BoolValue" => Ok(SType::SBoolean.into()),
+//        "IntValue" => Ok(SType::SInt.into()),
+//        "ShortValue" => Ok(SType::SShort.into()),
+//        "LongValue" => Ok(SType::SLong.into()),
+//        "BigIntValue" => Ok(SType::SBigInt.into()),
+//        "ByteValue" => Ok(SType::SByte.into()),
+//        "SigmaPropValue" => Ok(SType::SSigmaProp.into()),
+//        "SByte" => {
+//            handle_dot_type(buf)?;
+//            Ok(ExtractedType::FullySpecified(SType::SByte))
+//        }
+//        "Value" => {
+//            let content;
+//            let _bracketed = syn::bracketed!(content in buf);
+//            let next_ident: syn::Ident = content.parse()?;
+//            match &*next_ident.to_string() {
+//                "STuple" => Ok(ExtractedType::STuple),
+//                "SByte" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SByte))
+//                }
+//                "SGroupElement" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SGroupElement))
+//                }
+//                "SInt" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SInt))
+//                }
+//                "SLong" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SLong))
+//                }
+//                "SBigInt" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SBigInt))
+//                }
+//                "SBoolean" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SBoolean))
+//                }
+//                "SAvlTree" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SAvlTree))
+//                }
+//                "SBox" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SBox))
+//                }
+//                "SSigmaProp" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SSigmaProp))
+//                }
+//                "SHeader" => {
+//                    handle_dot_type(buf)?;
+//                    Ok(ExtractedType::FullySpecified(SType::SHeader))
+//                }
+//                "SOption" => {
+//                    let content_nested;
+//                    let _bracketed = syn::bracketed!(content_nested in content);
+//                    Ok(ExtractedType::SOption(Box::new(
+//                        extract_tpe_from_dot_typed(&content_nested)?,
+//                    )))
+//                }
+//                "SCollection" => {
+//                    let content_nested;
+//                    let _bracketed = syn::bracketed!(content_nested in content);
+//
+//                    //let _ident: syn::Ident = content_nested.parse()?;
+//                    //handle_dot_type(&content_nested)?;
+//                    Ok(ExtractedType::SCollection(Box::new(
+//                        extract_tpe_from_dot_typed(&content_nested)?,
+//                    )))
+//                }
+//                t => {
+//                    unreachable!("unknown ident T in _.typed[Value[T]]: T = {}", t)
+//                }
+//            }
+//        }
+//        t => unreachable!("unknown ident T in _.typed[T]: T = {}", t),
+//    }
+//}
+
+/// Parses `.type` from the buffered token stream
+pub fn handle_dot_type(buf: syn::parse::ParseStream) -> Result<(), syn::Error> {
+    let _dot: syn::Token![.] = buf.parse()?;
+    let ident: syn::Ident = buf.call(Ident::parse_any)?; //buf.parse()?;
+    if ident != "type" {
+        return Err(syn::Error::new_spanned(ident, ""));
+    }
+    Ok(())
+}

ergotree-ir/src/lib.rs

@@ -14,7 +14,7 @@
 #![deny(rustdoc::broken_intra_doc_links)]
 #![deny(clippy::unwrap_used)]
 #![deny(clippy::expect_used)]
-#![deny(clippy::todo)]
+//#![deny(clippy::todo)]
 #![deny(clippy::unimplemented)]
 #![deny(clippy::panic)]
 
@@ -30,3 +30,6 @@ pub mod sigma_protocol;
 pub mod type_check;
 pub mod types;
 pub mod util;
+
+#[cfg(feature = "ergotree-proc-macro")]
+pub mod ergotree_proc_macro;