Merge pull request #27794 from AleoHQ/feat/futures

Feat/futures

.github/workflows/acl2.yml

@@ -1,7 +1,7 @@
 name: Leo-ACL2
 on: workflow_dispatch
 env:
-  RUST_BACKTRACE: 1
+  RUST_BACKTRACE: 0
 
 # This job can only be run on linux (Ubuntu)
 jobs:

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
         - 'docs/**'
         - 'documentation/**'
 env:
-  RUST_BACKTRACE: 1
+  RUST_BACKTRACE: 0
 
 jobs:
   test-package:

.github/workflows/codecov.yml

@@ -7,7 +7,7 @@ on:
       - 'docs/**'
       - 'documentation/**'
 env:
-  RUST_BACKTRACE: 1
+  RUST_BACKTRACE: 0
 
 jobs:
   codecov:

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
 
 env:
-  RUST_BACKTRACE: 1
+  RUST_BACKTRACE: 0
 
 jobs:
   ubuntu:

compiler/ast/src/common/mod.rs

@@ -14,6 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
+pub mod location;
+pub use location::*;
+
 pub mod identifier;
 pub use identifier::*;
 
@@ -29,5 +32,4 @@ pub mod node_builder;
 pub use node_builder::*;
 
 pub mod static_string;
-
 pub use static_string::*;

compiler/ast/src/functions/core_function.rs

@@ -288,6 +288,7 @@ pub enum CoreFunction {
     GroupToYCoordinate,
 
     SignatureVerify,
+    FutureAwait,
 }
 
 impl CoreFunction {
@@ -564,6 +565,7 @@ impl CoreFunction {
             (sym::group, sym::to_y_coordinate) => Self::GroupToYCoordinate,
 
             (sym::signature, sym::verify) => Self::SignatureVerify,
+            (sym::Future, sym::Await) => Self::FutureAwait,
             _ => return None,
         })
     }
@@ -841,13 +843,15 @@ impl CoreFunction {
             Self::GroupToYCoordinate => 1,
 
             Self::SignatureVerify => 3,
+            Self::FutureAwait => 1,
         }
     }
 
     /// Returns whether or not this function is finalize command.
     pub fn is_finalize_command(&self) -> bool {
         match self {
-            CoreFunction::ChaChaRandAddress
+            CoreFunction::FutureAwait
+            | CoreFunction::ChaChaRandAddress
             | CoreFunction::ChaChaRandBool
             | CoreFunction::ChaChaRandField
             | CoreFunction::ChaChaRandGroup

compiler/ast/src/functions/mod.rs

@@ -26,9 +26,6 @@ pub use variant::*;
 pub mod external;
 pub use external::*;
 
-pub mod finalize;
-pub use finalize::*;
-
 pub mod input;
 pub use input::*;
 
@@ -61,8 +58,6 @@ pub struct Function {
     pub output_type: Type,
     /// The body of the function.
     pub block: Block,
-    /// An optional finalize block
-    pub finalize: Option<Finalize>,
     /// The entire span of the function definition.
     pub span: Span,
     /// The ID of the node.
@@ -87,7 +82,6 @@ impl Function {
         input: Vec<Input>,
         output: Vec<Output>,
         block: Block,
-        finalize: Option<Finalize>,
         span: Span,
         id: NodeID,
     ) -> Self {
@@ -103,7 +97,7 @@ impl Function {
             _ => Type::Tuple(TupleType::new(output.iter().map(get_output_type).collect())),
         };
 
-        Function { annotations, variant, identifier, input, output, output_type, block, finalize, span, id }
+        Function { annotations, variant, identifier, input, output, output_type, block, span, id }
     }
 
     /// Returns function name.
@@ -117,8 +111,8 @@ impl Function {
     fn format(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.variant {
             Variant::Inline => write!(f, "inline ")?,
-            Variant::Standard => write!(f, "function ")?,
-            Variant::Transition => write!(f, "transition ")?,
+            Variant::Function | Variant::AsyncFunction => write!(f, "function ")?,
+            Variant::Transition | Variant::AsyncTransition => write!(f, "transition ")?,
         }
         write!(f, "{}", self.identifier)?;
 
@@ -130,18 +124,12 @@ impl Function {
         };
         write!(f, "({parameters}) -> {returns} {}", self.block)?;
 
-        if let Some(finalize) = &self.finalize {
-            let parameters = finalize.input.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",");
-            write!(f, " finalize ({parameters}) {}", finalize.block)
-        } else {
-            Ok(())
-        }
+        Ok(())
     }
 }
 
 impl From<FunctionStub> for Function {
     fn from(function: FunctionStub) -> Self {
-        let finalize = function.finalize_stub.map(Finalize::from);
         Self {
             annotations: function.annotations,
             variant: function.variant,
@@ -150,7 +138,6 @@ impl From<FunctionStub> for Function {
             output: function.output,
             output_type: function.output_type,
             block: Block::default(),
-            finalize,
             span: function.span,
             id: function.id,
         }

compiler/ast/src/functions/variant.rs

@@ -16,13 +16,34 @@
 
 use serde::{Deserialize, Serialize};
 
-/// Functions are always one of three variants.
+/// Functions are always one of five variants.
 /// A transition function is permitted the ability to manipulate records.
+/// An asynchronous transition function is a transition function that calls an asynchronous function.
 /// A regular function is not permitted to manipulate records.
+/// An asynchronous function contains on-chain operations.
 /// An inline function is directly copied at the call site.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub enum Variant {
     Inline,
-    Standard,
+    Function,
     Transition,
+    AsyncTransition,
+    AsyncFunction,
+}
+
+impl Variant {
+    /// Returns true if the variant is async.
+    pub fn is_async(self) -> bool {
+        matches!(self, Variant::AsyncFunction | Variant::AsyncTransition)
+    }
+
+    /// Returns true if the variant is a transition.
+    pub fn is_transition(self) -> bool {
+        matches!(self, Variant::Transition | Variant::AsyncTransition)
+    }
+
+    /// Returns true if the variant is a function.
+    pub fn is_function(self) -> bool {
+        matches!(self, Variant::AsyncFunction | Variant::Function)
+    }
 }

compiler/ast/src/passes/reconstructor.rs

@@ -141,7 +141,7 @@ pub trait ExpressionReconstructor {
     fn reconstruct_call(&mut self, input: CallExpression) -> (Expression, Self::AdditionalOutput) {
         (
             Expression::Call(CallExpression {
-                function: Box::new(self.reconstruct_expression(*input.function).0),
+                function: input.function,
                 arguments: input.arguments.into_iter().map(|arg| self.reconstruct_expression(arg).0).collect(),
                 program: input.program,
                 span: input.span,
@@ -402,9 +402,6 @@ pub trait StatementReconstructor: ExpressionReconstructor {
         (
             Statement::Return(ReturnStatement {
                 expression: self.reconstruct_expression(input.expression).0,
-                finalize_arguments: input.finalize_arguments.map(|arguments| {
-                    arguments.into_iter().map(|argument| self.reconstruct_expression(argument).0).collect()
-                }),
                 span: input.span,
                 id: input.id,
             }),
@@ -470,15 +467,6 @@ pub trait ProgramReconstructor: StatementReconstructor {
             output: input.output,
             output_type: input.output_type,
             block: self.reconstruct_block(input.block).0,
-            finalize: input.finalize.map(|finalize| Finalize {
-                identifier: finalize.identifier,
-                input: finalize.input,
-                output: finalize.output,
-                output_type: finalize.output_type,
-                block: self.reconstruct_block(finalize.block).0,
-                span: finalize.span,
-                id: finalize.id,
-            }),
             span: input.span,
             id: input.id,
         }

compiler/ast/src/passes/visitor.rs

@@ -215,11 +215,6 @@ pub trait StatementVisitor<'a>: ExpressionVisitor<'a> {
 
     fn visit_return(&mut self, input: &'a ReturnStatement) {
         self.visit_expression(&input.expression, &Default::default());
-        if let Some(arguments) = &input.finalize_arguments {
-            arguments.iter().for_each(|argument| {
-                self.visit_expression(argument, &Default::default());
-            })
-        }
     }
 }
 
@@ -253,9 +248,6 @@ pub trait ProgramVisitor<'a>: StatementVisitor<'a> {
 
     fn visit_function(&mut self, input: &'a Function) {
         self.visit_block(&input.block);
-        if let Some(finalize) = &input.finalize {
-            self.visit_block(&finalize.block);
-        }
     }
 
     fn visit_function_stub(&mut self, _input: &'a FunctionStub) {}

compiler/ast/src/statement/return_.rs

@@ -25,8 +25,6 @@ use std::fmt;
 pub struct ReturnStatement {
     /// The expression to return to the function caller.
     pub expression: Expression,
-    /// Arguments to the finalize block.
-    pub finalize_arguments: Option<Vec<Expression>>,
     /// The span of `return expression` excluding the semicolon.
     pub span: Span,
     /// The ID of the node.