Migrates imports

compiler/src/constraints/import.rs

@@ -3,9 +3,10 @@ use crate::{
     errors::constraints::ImportError,
     new_scope,
     types::Program,
-    GroupType, Import,
+    GroupType,
 };
 use leo_ast::{ast, files::File};
+use leo_types::{Import};
 
 use from_pest::FromPest;
 use snarkos_models::{

compiler/src/lib.rs

@@ -16,9 +16,6 @@ pub use self::field::*;
 pub mod group;
 pub use self::group::*;
 
-pub mod imports;
-pub use self::imports::*;
-
 pub mod types;
 pub use self::types::*;
 

compiler/src/types.rs

@@ -1,8 +1,7 @@
 //! A typed Leo program consists of import, circuit, and function definitions.
 //! Each defined type consists of typed statements and expressions.
 
-use crate::Import;
-use leo_types::{Circuit, Identifier, Function, TestFunction};
+use leo_types::{Circuit, Identifier,Import, Function, TestFunction};
 
 use std::collections::HashMap;
 

compiler/src/types_from.rs

@@ -1,41 +1,13 @@
 //! Logic to convert from an abstract syntax tree (ast) representation to a Leo program.
 
-use crate::{types, Import, ImportSymbol};
+use crate::{types};
 use leo_ast::{
     files::File,
-    imports::{
-        Import as AstImport,
-        ImportSymbol as AstImportSymbol,
-    },
 };
-use leo_types::{Circuit, Function, Identifier, TestFunction};
+use leo_types::{Circuit, Function, Import, Identifier, TestFunction};
 
 use std::collections::HashMap;
 
-/// pest ast -> Import
-
-impl<'ast> From<AstImportSymbol<'ast>> for ImportSymbol {
-    fn from(symbol: AstImportSymbol<'ast>) -> Self {
-        ImportSymbol {
-            symbol: Identifier::from(symbol.value),
-            alias: symbol.alias.map(|alias| Identifier::from(alias)),
-        }
-    }
-}
-
-impl<'ast> From<AstImport<'ast>> for Import {
-    fn from(import: AstImport<'ast>) -> Self {
-        Import {
-            path_string: import.source.value,
-            symbols: import
-                .symbols
-                .into_iter()
-                .map(|symbol| ImportSymbol::from(symbol))
-                .collect(),
-        }
-    }
-}
-
 /// pest ast -> types::Program
 
 impl<'ast> types::Program {

types/src/imports/import.rs

@@ -1,21 +1,29 @@
-//! The Import type for a Leo program.
+//! The import type for a Leo program.
 
-use leo_types::Identifier;
+use crate::ImportSymbol;
+use leo_ast::imports::Import as AstImport;
 
 use std::fmt;
 
-#[derive(Clone)]
-pub struct ImportSymbol {
-    pub symbol: Identifier,
-    pub alias: Option<Identifier>,
-}
-
 #[derive(Clone)]
 pub struct Import {
     pub path_string: String,
     pub symbols: Vec<ImportSymbol>,
 }
 
+impl<'ast> From<AstImport<'ast>> for Import {
+    fn from(import: AstImport<'ast>) -> Self {
+        Import {
+            path_string: import.source.value,
+            symbols: import
+                .symbols
+                .into_iter()
+                .map(|symbol| ImportSymbol::from(symbol))
+                .collect(),
+        }
+    }
+}
+
 impl Import {
     pub fn new(source: String, symbols: Vec<ImportSymbol>) -> Import {
         Import {
@@ -50,16 +58,6 @@ impl Import {
     }
 }
 
-impl fmt::Display for ImportSymbol {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.alias.is_some() {
-            write!(f, "\t{} as {}", self.symbol, self.alias.as_ref().unwrap())
-        } else {
-            write!(f, "\t{}", self.symbol)
-        }
-    }
-}
-
 impl<'ast> fmt::Display for Import {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.format(f)

types/src/imports/import_symbol.rs

@@ -0,0 +1,29 @@
+use crate::Identifier;
+use leo_ast::imports::ImportSymbol as AstImportSymbol;
+
+use std::fmt;
+
+#[derive(Clone)]
+pub struct ImportSymbol {
+    pub symbol: Identifier,
+    pub alias: Option<Identifier>,
+}
+
+impl<'ast> From<AstImportSymbol<'ast>> for ImportSymbol {
+    fn from(symbol: AstImportSymbol<'ast>) -> Self {
+        ImportSymbol {
+            symbol: Identifier::from(symbol.value),
+            alias: symbol.alias.map(|alias| Identifier::from(alias)),
+        }
+    }
+}
+
+impl fmt::Display for ImportSymbol {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.alias.is_some() {
+            write!(f, "\t{} as {}", self.symbol, self.alias.as_ref().unwrap())
+        } else {
+            write!(f, "\t{}", self.symbol)
+        }
+    }
+}

types/src/imports/mod.rs

@@ -0,0 +1,5 @@
+pub mod import;
+pub use import::*;
+
+pub mod import_symbol;
+pub use import_symbol::*;

types/src/lib.rs

@@ -16,6 +16,9 @@ pub use expression::*;
 pub mod functions;
 pub use functions::*;
 
+pub mod imports;
+pub use imports::*;
+
 pub mod input_value;
 pub use input_value::*;