refactor(dan): template macro as an attribute macro #4361
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…macro-improvements
sdbondi
approved these changes
Jul 29, 2022
sdbondi
reviewed
Jul 29, 2022
Comment on lines
+105
to
+118
| let input = TokenStream::from_str(indoc! {" | ||
| mod foo { | ||
| struct Foo {} | ||
| impl Foo { | ||
| pub fn no_args_function() -> String { | ||
| \"Hello World!\".to_string() | ||
| } | ||
| pub fn some_args_function(a: i8, b: String) -> u32 { | ||
| 1_u32 | ||
| } | ||
| pub fn no_return_function() {} | ||
| } | ||
| } | ||
| "}) |
There was a problem hiding this comment.
You can also use native rust multiline strings
Suggested change
| let input = TokenStream::from_str(indoc! {" | |
| mod foo { | |
| struct Foo {} | |
| impl Foo { | |
| pub fn no_args_function() -> String { | |
| \"Hello World!\".to_string() | |
| } | |
| pub fn some_args_function(a: i8, b: String) -> u32 { | |
| 1_u32 | |
| } | |
| pub fn no_return_function() {} | |
| } | |
| } | |
| "}) | |
| let input = TokenStream::from_str( | |
| r#" | |
| mod hello_world { | |
| struct HelloWorld {} | |
| impl HelloWorld { | |
| pub fn greet() -> String { | |
| "Hello World!".to_string() | |
| } | |
| } | |
| } | |
| "#, | |
| ) | |
| .unwrap(); |
There was a problem hiding this comment.
The parser was giving me a hard time with native multilines due to some span issues. Using indoc we can avoid those kind of issues and it's a dev-dependency used only in tests, so my vote goes to indoc.
There was a problem hiding this comment.
Thanks for the explanation - sounds good to me
stringhandler
pushed a commit
that referenced
this pull request
Aug 3, 2022
Description
---
* Function parameters are correctly encoded and passed to the user function
* Component parameters (i.e. `self`) are transparently handled to the user code:
1. The ABI specifies a `u32` type component id
2. The state is retrieved from the engine with that component id (not the real call yet, as it's not implemented in the engine)
3. The state is decoded and passed to the function on the `self` parameter
4. If the attribute is mutable (`&mut self`) then we call the engine to update the component state
* Unit return types (`()`) are now supported in functions (see the `State.set` function as an example)
* Expanded the `ast.rs` module with convenient functions to detect `self` and constructor functions
Motivation and Context
---
Following the previous work on the template macro (#4358, #4361), this PR aims to solve some of the previous limitations:
* The function arguments must be processed and encoded
* Struct fields and `self` must be handled
* Calls to the tari engine import should be done instead of mocked
With those implemented, the `state` test example is now written as:
```
use tari_template_macros::template;
#[template]
mod state_template {
pub struct State {
pub value: u32,
}
impl State {
pub fn new() -> Self {
Self { value: 0 }
}
pub fn set(&mut self, value: u32) {
self.value = value;
}
pub fn get(&self) -> u32 {
self.value
}
}
}
```
Please keep in mind that this is the simplest example that manages the contract state, but it currently supports function logic as complex as the user wants, as long as it is valid Rust code.
Also, for now I didn't find necessary to mark constructor functions in any special way. Right now, a function is automatically considered a constructor (and the component instantiated) if it returns `Self`.
Lastly, as the state managing itself is not yet implemented on the engine, state is not conserved between calls. But this PR encapsulates component related logic in a single module (`component.rs`) so it should be relatively simple to implement in the future.
How Has This Been Tested?
---
The unit test for the `state` example, now rewritten using the template macro, pass
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Description
template!) into an attribute one (#[template])dan_layercrateindoc!macro in tests to make the code more readableMotivation and Context
The existing template definition macro was created as a declarative macro, but code completion on some editors breaks when wrapped such types of macros.
The main goal of this PR is to transform the template macro into an attribute macro, to be used like:
How Has This Been Tested?