Merge branch 'master' of github.com:AleoHQ/leo into feature/type-inference

ast/benches/leo_ast.rs

@@ -14,14 +14,14 @@
 // 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 leo_ast::LeoAst;
+use leo_ast::Ast;
 use leo_grammar::Grammar;
 
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::{path::Path, time::Duration};
 
-fn leo_ast<'ast>(ast: &Grammar<'ast>) -> LeoAst {
-    LeoAst::new("leo_tree", &ast)
+fn ast<'ast>(ast: &Grammar<'ast>) -> Ast {
+    Ast::new("leo_tree", &ast)
 }
 
 fn bench_big_if_else(c: &mut Criterion) {
@@ -29,7 +29,7 @@ fn bench_big_if_else(c: &mut Criterion) {
     let program_string = include_str!("./big_if_else.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::big_if_else", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::big_if_else", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_big_ternary(c: &mut Criterion) {
@@ -37,7 +37,7 @@ fn bench_big_ternary(c: &mut Criterion) {
     let program_string = include_str!("./big_ternary.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::big_ternary", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::big_ternary", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_big_circuit(c: &mut Criterion) {
@@ -45,7 +45,7 @@ fn bench_big_circuit(c: &mut Criterion) {
     let program_string = include_str!("./big_circuit.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::big_circuit", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::big_circuit", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_long_expr(c: &mut Criterion) {
@@ -53,7 +53,7 @@ fn bench_long_expr(c: &mut Criterion) {
     let program_string = include_str!("./long_expr.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::long_expr", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::long_expr", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_long_array(c: &mut Criterion) {
@@ -61,7 +61,7 @@ fn bench_long_array(c: &mut Criterion) {
     let program_string = include_str!("./long_array.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::long_array", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::long_array", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_many_foos(c: &mut Criterion) {
@@ -69,7 +69,7 @@ fn bench_many_foos(c: &mut Criterion) {
     let program_string = include_str!("./many_foos.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::many_foos", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::many_foos", |b| b.iter(|| ast(&ast)));
 }
 
 fn bench_many_assigns(c: &mut Criterion) {
@@ -77,7 +77,7 @@ fn bench_many_assigns(c: &mut Criterion) {
     let program_string = include_str!("./many_assigns.leo");
     let ast = Grammar::new(&filepath, program_string).unwrap();
 
-    c.bench_function("LeoAst::many_assigns", |b| b.iter(|| leo_ast(&ast)));
+    c.bench_function("Ast::many_assigns", |b| b.iter(|| ast(&ast)));
 }
 
 criterion_group!(

ast/src/lib.rs

@@ -16,9 +16,9 @@
 
 //! The abstract syntax tree (ast) for a Leo program.
 //!
-//! This module contains the [`LeoAst`] type, a wrapper around the [`Program`] type.
-//! The [`LeoAst`] type is intended to be parsed and modified by different passes
-//! of the Leo compiler. The Leo compiler can generate a set of R1CS constraints from any [`LeoAst`].
+//! This module contains the [`Ast`] type, a wrapper around the [`Program`] type.
+//! The [`Ast`] type is intended to be parsed and modified by different passes
+//! of the Leo compiler. The Leo compiler can generate a set of R1CS constraints from any [`Ast`].
 
 pub mod annotation;
 pub use self::annotation::*;
@@ -63,34 +63,34 @@ use leo_grammar::Grammar;
 
 /// The abstract syntax tree (ast) for a Leo program.
 ///
-/// The [`LeoAst`] type represents a Leo program as a series of recursive data types.
+/// The [`Ast`] type represents a Leo program as a series of recursive data types.
 /// These data types form a tree that begins from a [`Program`] type root.
 ///
-/// A new [`LeoAst`] can be created from a [`Grammar`] generated by the pest parser in the `grammar` module.
+/// A new [`Ast`] can be created from a [`Grammar`] generated by the pest parser in the `grammar` module.
 #[derive(Debug, Eq, PartialEq)]
-pub struct LeoAst {
+pub struct Ast {
     ast: Program,
 }
 
-impl LeoAst {
-    /// Creates a new syntax tree from a given program name and abstract syntax tree.
+impl Ast {
+    /// Creates a new ast from a given program name and grammar tree.
     pub fn new<'ast>(program_name: &str, ast: &Grammar<'ast>) -> Self {
         Self {
             ast: Program::from(program_name, ast.as_repr()),
         }
     }
 
-    /// Returns a reference to the inner program syntax tree representation.
+    /// Returns a reference to the inner program ast representation.
     pub fn into_repr(self) -> Program {
         self.ast
     }
 
-    /// Serializes the syntax tree into a JSON string.
+    /// Serializes the ast into a JSON string.
     pub fn to_json_string(&self) -> Result<String, serde_json::Error> {
         Ok(serde_json::to_string_pretty(&self.ast)?)
     }
 
-    /// Deserializes the JSON string into a syntax tree.
+    /// Deserializes the JSON string into a ast.
     pub fn from_json_string(json: &str) -> Result<Self, serde_json::Error> {
         let ast: Program = serde_json::from_str(json)?;
         Ok(Self { ast })

ast/src/main.rs

@@ -14,7 +14,7 @@
 // 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 leo_ast::LeoAst;
+use leo_ast::Ast;
 use leo_grammar::{Grammar, ParserError};
 use std::{env, fs, path::Path};
 
@@ -27,10 +27,10 @@ fn to_leo_tree(filepath: &Path) -> Result<String, ParserError> {
     let ast = Grammar::new(&program_filepath, &program_string)?;
 
     // Parse the pest ast and constructs a ast.
-    let leo_ast = LeoAst::new("leo_tree", &ast);
+    let leo_ast = Ast::new("leo_tree", &ast);
 
     // Serializes the tree into JSON format.
-    let serialized_leo_ast = LeoAst::to_json_string(&leo_ast)?;
+    let serialized_leo_ast = Ast::to_json_string(&leo_ast)?;
 
     Ok(serialized_leo_ast)
 }

ast/tests/serialization/json.rs

@@ -14,14 +14,14 @@
 // 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 leo_ast::LeoAst;
+use leo_ast::Ast;
 #[cfg(not(feature = "ci_skip"))]
 use leo_ast::Program;
 use leo_grammar::Grammar;
 
 use std::path::{Path, PathBuf};
 
-fn to_ast(program_filepath: &Path) -> LeoAst {
+fn to_ast(program_filepath: &Path) -> Ast {
     // Loads the Leo code as a string from the given file path.
     let program_string = Grammar::load_file(program_filepath).unwrap();
 
@@ -29,14 +29,14 @@ fn to_ast(program_filepath: &Path) -> LeoAst {
     let ast = Grammar::new(&program_filepath, &program_string).unwrap();
 
     // Parses the pest ast and constructs a Leo ast.
-    LeoAst::new("leo_tree", &ast)
+    Ast::new("leo_tree", &ast)
 }
 
 #[test]
 #[cfg(not(feature = "ci_skip"))]
 fn test_serialize() {
-    // Construct a ast from the given test file.
-    let leo_ast = {
+    // Construct an ast from the given test file.
+    let ast = {
         let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         program_filepath.push("tests/serialization/main.leo");
 
@@ -44,20 +44,19 @@ fn test_serialize() {
     };
 
     // Serializes the ast into JSON format.
-    let serialized_leo_ast: Program =
-        serde_json::from_value(serde_json::to_value(leo_ast.into_repr()).unwrap()).unwrap();
+    let serialized_ast: Program = serde_json::from_value(serde_json::to_value(ast.into_repr()).unwrap()).unwrap();
 
     // Load the expected ast.
     let expected: Program = serde_json::from_str(include_str!("expected_leo_ast.json")).unwrap();
 
-    assert_eq!(expected, serialized_leo_ast);
+    assert_eq!(expected, serialized_ast);
 }
 
 #[test]
 #[cfg(not(feature = "ci_skip"))]
 fn test_deserialize() {
     // Load the expected ast.
-    let expected_leo_ast = {
+    let expected_ast = {
         let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         program_filepath.push("tests/serialization/main.leo");
 
@@ -66,15 +65,15 @@ fn test_deserialize() {
 
     // Construct an ast by deserializing a ast JSON file.
     let serialized_ast = include_str!("expected_leo_ast.json");
-    let leo_ast = LeoAst::from_json_string(serialized_ast).unwrap();
+    let ast = Ast::from_json_string(serialized_ast).unwrap();
 
-    assert_eq!(expected_leo_ast, leo_ast);
+    assert_eq!(expected_ast, ast);
 }
 
 #[test]
 fn test_serialize_deserialize_serialize() {
-    // Construct a ast from the given test file.
-    let leo_ast = {
+    // Construct an ast from the given test file.
+    let ast = {
         let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         program_filepath.push("tests/serialization/main.leo");
 
@@ -82,13 +81,13 @@ fn test_serialize_deserialize_serialize() {
     };
 
     // Serializes the ast into JSON format.
-    let serialized_leo_ast = leo_ast.to_json_string().unwrap();
+    let serialized_ast = ast.to_json_string().unwrap();
 
-    // Deserializes the serialized ast into a LeoAst.
-    let leo_ast = LeoAst::from_json_string(&serialized_leo_ast).unwrap();
+    // Deserializes the serialized ast into an ast.
+    let ast = Ast::from_json_string(&serialized_ast).unwrap();
 
     // Reserializes the ast into JSON format.
-    let reserialized_leo_ast = leo_ast.to_json_string().unwrap();
+    let reserialized_ast = ast.to_json_string().unwrap();
 
-    assert_eq!(serialized_leo_ast, reserialized_leo_ast);
+    assert_eq!(serialized_ast, reserialized_ast);
 }

compiler/src/compiler.rs

@@ -23,7 +23,7 @@ use crate::{
     OutputBytes,
     OutputFile,
 };
-use leo_ast::{Input, LeoAst, MainInput, Program};
+use leo_ast::{Ast, Input, MainInput, Program};
 use leo_grammar::Grammar;
 use leo_imports::ImportParser;
 use leo_input::LeoInputParser;
@@ -184,7 +184,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
         })?;
 
         // Construct the core ast from the pest ast.
-        let core_ast = LeoAst::new(&self.package_name, &pest_ast);
+        let core_ast = Ast::new(&self.package_name, &pest_ast);
 
         // Store the main program file.
         self.program = core_ast.into_repr();
@@ -244,7 +244,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
         let package_name = &self.package_name;
 
         // Construct the core ast from the pest ast.
-        let core_ast = LeoAst::new(package_name, &ast);
+        let core_ast = Ast::new(package_name, &ast);
 
         // Store the main program file.
         self.program = core_ast.into_repr();

compiler/src/constraints/constraints.rs

@@ -46,7 +46,7 @@ pub fn generate_constraints<F: Field + PrimeField, G: GroupType<F>, CS: Constrai
     let program_name = program.get_name();
     let main_function_name = new_scope(&program_name, "main");
 
-    resolved_program.store_definitions(program, imported_programs)?;
+    resolved_program.store_definitions(&program, imported_programs)?;
 
     let main = resolved_program.get(&main_function_name).ok_or(CompilerError::NoMain)?;
 
@@ -72,7 +72,7 @@ pub fn generate_test_constraints<F: Field + PrimeField, G: GroupType<F>>(
     let tests = program.tests.clone();
 
     // Store definitions
-    resolved_program.store_definitions(program, imported_programs)?;
+    resolved_program.store_definitions(&program, imported_programs)?;
 
     // Get default input
     let default = input.pairs.get(&program_name);

compiler/src/definition/definitions.rs

@@ -28,7 +28,11 @@ use leo_imports::ImportParser;
 use snarkos_models::curves::{Field, PrimeField};
 
 impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
-    pub fn store_definitions(&mut self, program: Program, imported_programs: &ImportParser) -> Result<(), ImportError> {
+    pub fn store_definitions(
+        &mut self,
+        program: &Program,
+        imported_programs: &ImportParser,
+    ) -> Result<(), ImportError> {
         let program_name = program.name.trim_end_matches(".leo");
 
         // evaluate all import statements and store imported definitions
@@ -39,15 +43,21 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
             .collect::<Result<Vec<_>, ImportError>>()?;
 
         // evaluate and store all circuit definitions
-        program.circuits.into_iter().for_each(|(identifier, circuit)| {
+        program.circuits.iter().for_each(|(identifier, circuit)| {
             let resolved_circuit_name = new_scope(program_name, &identifier.name);
-            self.store(resolved_circuit_name, ConstrainedValue::CircuitDefinition(circuit));
+            self.store(
+                resolved_circuit_name,
+                ConstrainedValue::CircuitDefinition(circuit.clone()),
+            );
         });
 
         // evaluate and store all function definitions
-        program.functions.into_iter().for_each(|(function_name, function)| {
+        program.functions.iter().for_each(|(function_name, function)| {
             let resolved_function_name = new_scope(program_name, &function_name.name);
-            self.store(resolved_function_name, ConstrainedValue::Function(None, function));
+            self.store(
+                resolved_function_name,
+                ConstrainedValue::Function(None, function.clone()),
+            );
         });
 
         Ok(())

compiler/src/import/store/import.rs

@@ -47,7 +47,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
                 .ok_or_else(|| ImportError::unknown_package(import.package.name.clone()))?;
 
             // Parse imported program
-            self.store_definitions(program.clone(), imported_programs)?;
+            self.store_definitions(program, imported_programs)?;
 
             // Store the imported symbol
             self.store_symbol(scope, &name, &symbol, program)?;

grammar/src/lib.rs

@@ -18,7 +18,7 @@
 //!
 //! This module contains the [`Grammar`] type, a wrapper around the [`File`] type in this module.
 //! The [`Grammar`] type is the datatype generated by the pest parser using grammar from `leo.pest`.
-//! The [`Grammar`] type is intended to be parsed into a [`LeoAst`]. It should not be parsed by
+//! The [`Grammar`] type is intended to be parsed into a [`Ast`]. It should not be parsed by
 //! any other pass of the compiler.
 
 #[macro_use]
@@ -60,7 +60,7 @@ use std::{fs, path::Path};
 /// These data types form a tree that begins from a [`File`] type root.
 ///
 /// A new [`Grammar`] type can be created from a `*.leo` file at a [`Path`].
-/// A [`Grammar`] type can be used to create a new [`LeoAst`] type.
+/// A [`Grammar`] type can be used to create a new [`Ast`] type.
 pub struct Grammar<'ast> {
     ast: files::File<'ast>,
 }

symbol-table/src/types/functions/function_input_variable.rs

@@ -14,7 +14,7 @@
 // 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::{Attribute, SymbolTable, Type, TypeError, UserDefinedType};
+use crate::{Attribute, SymbolTable, Type, TypeError};
 use leo_ast::{FunctionInputVariable, Identifier, Span};
 
 use serde::{Deserialize, Serialize};
@@ -90,18 +90,6 @@ impl FunctionInputVariableType {
             span: unresolved_function_input.span,
         })
     }
-
-    ///
-    /// Insert the current function input variable type into the given symbol table.
-    ///
-    /// If the symbol table did not have this name present, `None` is returned.
-    ///
-    pub fn insert(&self, table: &mut SymbolTable) -> Option<UserDefinedType> {
-        let key = self.identifier.name.clone();
-        let value = UserDefinedType::from(self.clone());
-
-        table.insert_name(key, value)
-    }
 }
 
 impl PartialEq for FunctionInputVariableType {

symbol-table/tests/mod.rs

@@ -16,7 +16,7 @@
 
 pub mod symbol_table;
 
-use leo_ast::{Input, LeoAst};
+use leo_ast::{Ast, Input};
 use leo_grammar::Grammar;
 use leo_symbol_table::{SymbolTable, SymbolTableError};
 
@@ -27,7 +27,7 @@ const TEST_PROGRAM_PATH: &str = "";
 
 /// A helper struct to test a `SymbolTable`.
 pub struct TestSymbolTable {
-    ast: LeoAst,
+    ast: Ast,
 }
 
 impl TestSymbolTable {
@@ -41,11 +41,11 @@ impl TestSymbolTable {
         // Get test file path.
         let file_path = PathBuf::from(TEST_PROGRAM_PATH);
 
-        // Get parser syntax tree
+        // Get parser syntax tree.
         let grammar = Grammar::new(&file_path, &*file_string).unwrap();
 
-        // Get Leo syntax tree
-        let ast = LeoAst::new(TEST_PROGRAM_PATH, &grammar);
+        // Get Leo syntax tree.
+        let ast = Ast::new(TEST_PROGRAM_PATH, &grammar);
 
         Self { ast }
     }