add finalize

compiler/ast/src/stub/finalize_stub.rs

@@ -14,12 +14,19 @@
 // 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/>.
 
-use crate::{Identifier, Input, Node, NodeID, Output, TupleType, Type};
+use crate::{Finalize, FunctionInput, Identifier, Input, Mode, Node, NodeID, Output, TupleType, Type};
 
-use leo_span::Span;
+use leo_span::{Span, Symbol};
 
 use core::fmt;
 use serde::{Deserialize, Serialize};
+use snarkvm::{
+    prelude::{
+        FinalizeType::{Future, Plaintext},
+        Network,
+    },
+    synthesizer::program::{CommandTrait, FinalizeCore},
+};
 
 /// A finalize stub.
 #[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Debug)]
@@ -51,6 +58,34 @@ impl FinalizeStub {
     }
 }
 
+impl<N: Network, Command: CommandTrait<N>> From<&FinalizeCore<N, Command>> for FinalizeStub {
+    fn from(finalize: &FinalizeCore<N, Command>) -> Self {
+        let mut inputs = Vec::new();
+
+        finalize.inputs().iter().enumerate().for_each(|(index, input)| {
+            let arg_name = Identifier::new(Symbol::intern(&format!("a{}", index + 1)), Default::default());
+            match input.finalize_type() {
+                Plaintext(val) => inputs.push(Input::Internal(FunctionInput {
+                    identifier: arg_name,
+                    mode: Mode::None,
+                    type_: Type::from(val),
+                    span: Default::default(),
+                    id: Default::default(),
+                })),
+                Future(_) => {} // Don't need to worry about nested futures
+            }
+        });
+
+        Self::new(Identifier::from(finalize.name()), inputs, Vec::new(), Default::default(), Default::default())
+    }
+}
+
+impl From<Finalize> for FinalizeStub {
+    fn from(finalize: Finalize) -> Self {
+        Self::new(finalize.identifier, finalize.input, finalize.output, Default::default(), Default::default())
+    }
+}
+
 impl fmt::Display for FinalizeStub {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let parameters = self.input.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",");

compiler/ast/src/stub/function_stub.rs

@@ -14,7 +14,24 @@
 // 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/>.
 
-use crate::{finalize_stub::*, Annotation, Identifier, Input, Node, NodeID, Output, TupleType, Type, Variant};
+use crate::{
+    finalize_stub::*,
+    Annotation,
+    External,
+    Function,
+    FunctionInput,
+    FunctionOutput,
+    Identifier,
+    Input,
+    Mode,
+    Node,
+    NodeID,
+    Output,
+    ProgramId,
+    TupleType,
+    Type,
+    Variant,
+};
 use leo_span::{sym, Span, Symbol};
 
 use crate::Type::Identifier as IdentifierType;
@@ -133,8 +150,7 @@ impl From<Function> for FunctionStub {
             input: function.input,
             output: function.output,
             output_type: function.output_type,
-            block: function.block,
-            finalize: function.finalize,
+            finalize_stub: function.finalize.map(FinalizeStub::from),
             span: function.span,
             id: function.id,
         }
@@ -196,10 +212,9 @@ impl<N: Network, Instruction: InstructionTrait<N>> From<&ClosureCore<N, Instruct
                 .collect_vec(),
             output: outputs,
             output_type,
-            block: Block { statements: Vec::new(), span: Default::default(), id: Default::default() },
-            finalize: None,
             span: Default::default(),
             id: Default::default(),
+            finalize_stub: None,
         }
     }
 }
@@ -312,8 +327,7 @@ impl<N: Network, Instruction: InstructionTrait<N>, Command: CommandTrait<N>>
                 .collect_vec(),
             output: outputs,
             output_type,
-            block: Block { statements: Vec::new(), span: Default::default(), id: Default::default() },
-            finalize: None,
+            finalize_stub: function.finalize_logic().map(FinalizeStub::from),
             span: Default::default(),
             id: Default::default(),
         }

compiler/ast/src/stub/mod.rs

@@ -51,12 +51,12 @@ impl fmt::Display for Stub {
         for import in self.imports.iter() {
             writeln!(f, "    import {import}")?;
         }
-        for (_, struct_) in self.structs.iter() {
-            writeln!(f, "    {struct_}")?;
-        }
         for (_, mapping) in self.mappings.iter() {
             writeln!(f, "    {mapping}")?;
         }
+        for (_, struct_) in self.structs.iter() {
+            writeln!(f, "    {struct_}")?;
+        }
         for (_, function) in self.functions.iter() {
             writeln!(f, "    {function}")?;
         }