chore: remove pub wildcard import of ast into noirc_frontend root

aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs

@@ -1,8 +1,9 @@
 use noirc_errors::{Location, Span};
+use noirc_frontend::ast::{FunctionReturnType, NoirFunction, UnresolvedTypeData};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext},
-    parse_program, FunctionReturnType, NoirFunction, Type, UnresolvedTypeData,
+    parse_program, Type,
 };
 
 use crate::utils::{

aztec_macros/src/transforms/contract_interface.rs

@@ -1,9 +1,10 @@
+use noirc_frontend::ast::{NoirFunction, UnresolvedTypeData};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
     parse_program,
     parser::SortedModule,
-    NoirFunction, Type, UnresolvedTypeData,
+    Type,
 };
 
 use crate::utils::{
@@ -52,7 +53,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
         })
         .collect::<Vec<_>>()
         .join(", ");
-    let fn_return_type: noirc_frontend::UnresolvedType = func.return_type();
+    let fn_return_type: noirc_frontend::ast::UnresolvedType = func.return_type();
 
     let fn_selector = format!("dep::aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature(\"{}\")", SELECTOR_PLACEHOLDER);
 

aztec_macros/src/transforms/events.rs

@@ -1,5 +1,9 @@
 use iter_extended::vecmap;
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    ExpressionKind, FunctionDefinition, FunctionReturnType, ItemVisibility, Literal, NoirFunction,
+    Visibility,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{
@@ -8,8 +12,6 @@ use noirc_frontend::{
         UnresolvedTypeData,
     },
     token::SecondaryAttribute,
-    ExpressionKind, FunctionDefinition, FunctionReturnType, ItemVisibility, Literal, NoirFunction,
-    Visibility,
 };
 
 use crate::{

aztec_macros/src/transforms/functions.rs

@@ -1,12 +1,15 @@
 use convert_case::{Case, Casing};
 use noirc_errors::Span;
-use noirc_frontend::{
-    macros_api::FieldElement, parse_program, BlockExpression, ConstrainKind, ConstrainStatement,
-    Distinctness, Expression, ExpressionKind, ForLoopStatement, ForRange, FunctionReturnType,
-    Ident, Literal, NoirFunction, NoirStruct, Param, PathKind, Pattern, Signedness, Statement,
-    StatementKind, UnresolvedType, UnresolvedTypeData, Visibility,
+use noirc_frontend::ast;
+use noirc_frontend::ast::{
+    BlockExpression, ConstrainKind, ConstrainStatement, Distinctness, Expression, ExpressionKind,
+    ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal, NoirFunction, NoirStruct,
+    Param, PathKind, Pattern, Signedness, Statement, StatementKind, UnresolvedType,
+    UnresolvedTypeData, Visibility,
 };
 
+use noirc_frontend::{macros_api::FieldElement, parse_program};
+
 use crate::{
     chained_dep, chained_path,
     utils::{
@@ -334,7 +337,7 @@ fn serialize_to_hasher(
                 &UnresolvedType {
                     typ: UnresolvedTypeData::Integer(
                         Signedness::Unsigned,
-                        noirc_frontend::IntegerBitSize::ThirtyTwo,
+                        ast::IntegerBitSize::ThirtyTwo,
                     ),
                     span: None,
                 },

aztec_macros/src/transforms/note_interface.rs

@@ -1,12 +1,16 @@
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    ItemVisibility, LetStatement, NoirFunction, NoirStruct, PathKind, TraitImplItem, TypeImpl,
+    UnresolvedTypeData, UnresolvedTypeExpression,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
     parse_program,
     parser::SortedModule,
-    ItemVisibility, LetStatement, NoirFunction, NoirStruct, PathKind, TraitImplItem, Type,
-    TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
+    Type,
 };
+
 use regex::Regex;
 
 use crate::{

aztec_macros/src/transforms/storage.rs

@@ -1,6 +1,10 @@
 use std::borrow::Borrow;
 
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
+    NoirStruct, PathKind, Pattern, StatementKind, TypeImpl, UnresolvedType, UnresolvedTypeData,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{
@@ -10,9 +14,7 @@ use noirc_frontend::{
     parse_program,
     parser::SortedModule,
     token::SecondaryAttribute,
-    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
-    NoirStruct, PathKind, Pattern, StatementKind, Type, TypeImpl, UnresolvedType,
-    UnresolvedTypeData,
+    Type,
 };
 
 use crate::{

aztec_macros/src/utils/ast_utils.rs

@@ -1,10 +1,11 @@
 use noirc_errors::{Span, Spanned};
-use noirc_frontend::{
-    token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
-    ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
-    LetStatement, MethodCallExpression, NoirTraitImpl, Path, Pattern, PrefixExpression, Statement,
-    StatementKind, TraitImplItem, UnaryOp, UnresolvedType, UnresolvedTypeData,
+use noirc_frontend::ast::{
+    BinaryOpKind, CallExpression, CastExpression, Expression, ExpressionKind, FunctionReturnType,
+    Ident, IndexExpression, InfixExpression, Lambda, LetStatement, MethodCallExpression,
+    NoirTraitImpl, Path, Pattern, PrefixExpression, Statement, StatementKind, TraitImplItem,
+    UnaryOp, UnresolvedType, UnresolvedTypeData,
 };
+use noirc_frontend::token::SecondaryAttribute;
 
 //
 //             Helper macros for creating noir ast nodes

aztec_macros/src/utils/errors.rs

@@ -1,15 +1,16 @@
 use noirc_errors::Span;
-use noirc_frontend::{macros_api::MacroError, UnresolvedTypeData};
+use noirc_frontend::ast;
+use noirc_frontend::macros_api::MacroError;
 
 use super::constants::MAX_CONTRACT_PRIVATE_FUNCTIONS;
 
 #[derive(Debug, Clone)]
 pub enum AztecMacroError {
     AztecDepNotFound,
     ContractHasTooManyPrivateFunctions { span: Span },
-    UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
-    UnsupportedFunctionReturnType { span: Span, typ: UnresolvedTypeData },
-    UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
+    UnsupportedFunctionArgumentType { span: Span, typ: ast::UnresolvedTypeData },
+    UnsupportedFunctionReturnType { span: Span, typ: ast::UnresolvedTypeData },
+    UnsupportedStorageType { span: Option<Span>, typ: ast::UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
     CouldNotImplementComputeNoteHashAndNullifier { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },

aztec_macros/src/utils/hir_utils.rs

@@ -1,5 +1,6 @@
 use iter_extended::vecmap;
 use noirc_errors::Location;
+use noirc_frontend::ast;
 use noirc_frontend::{
     graph::CrateId,
     hir::{
@@ -9,7 +10,7 @@ use noirc_frontend::{
     },
     macros_api::{FileId, HirContext, MacroError, ModuleDefId, StructId},
     node_interner::{FuncId, TraitId},
-    ItemVisibility, LetStatement, NoirFunction, Shared, Signedness, StructType, Type,
+    Shared, StructType, Type,
 };
 
 use super::ast_utils::is_custom_attribute;
@@ -65,8 +66,8 @@ pub fn collect_traits(context: &HirContext) -> Vec<TraitId> {
 /// Computes the aztec signature for a resolved type.
 pub fn signature_of_type(typ: &Type) -> String {
     match typ {
-        Type::Integer(Signedness::Signed, bit_size) => format!("i{}", bit_size),
-        Type::Integer(Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
+        Type::Integer(ast::Signedness::Signed, bit_size) => format!("i{}", bit_size),
+        Type::Integer(ast::Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
         Type::FieldElement => "Field".to_owned(),
         Type::Bool => "bool".to_owned(),
         Type::Array(len, typ) => {
@@ -165,7 +166,7 @@ pub fn get_contract_module_data(
 pub fn inject_fn(
     crate_id: &CrateId,
     context: &mut HirContext,
-    func: NoirFunction,
+    func: ast::NoirFunction,
     location: Location,
     module_id: LocalModuleId,
     file_id: FileId,
@@ -179,7 +180,7 @@ pub fn inject_fn(
     );
 
     context.def_map_mut(crate_id).unwrap().modules_mut()[module_id.0]
-        .declare_function(func.name_ident().clone(), ItemVisibility::Public, func_id)
+        .declare_function(func.name_ident().clone(), ast::ItemVisibility::Public, func_id)
         .map_err(|err| MacroError {
             primary_message: format!("Failed to declare autogenerated {} function", func.name()),
             secondary_message: Some(format!("Duplicate definition found {}", err.0)),
@@ -214,7 +215,7 @@ pub fn inject_fn(
 pub fn inject_global(
     crate_id: &CrateId,
     context: &mut HirContext,
-    global: LetStatement,
+    global: ast::LetStatement,
     module_id: LocalModuleId,
     file_id: FileId,
 ) {

compiler/noirc_driver/src/abi_gen.rs

@@ -3,12 +3,12 @@ use std::collections::BTreeMap;
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
 use noirc_abi::{Abi, AbiParameter, AbiReturnType, AbiType, AbiValue};
+use noirc_frontend::ast::Visibility;
 use noirc_frontend::{
     hir::Context,
     hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern},
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
-    Visibility,
 };
 use std::ops::Range;
 

compiler/noirc_evaluator/src/ssa.rs

@@ -22,9 +22,8 @@ use acvm::acir::{
 
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
-use noirc_frontend::{
-    hir_def::function::FunctionSignature, monomorphization::ast::Program, Visibility,
-};
+use noirc_frontend::ast::Visibility;
+use noirc_frontend::{hir_def::function::FunctionSignature, monomorphization::ast::Program};
 use tracing::{span, Level};
 
 use self::{acir_gen::GeneratedAcir, ssa_gen::Ssa};

compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs

@@ -39,7 +39,7 @@ use acvm::{
 use fxhash::FxHashMap as HashMap;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
-use noirc_frontend::Distinctness;
+use noirc_frontend::ast::Distinctness;
 
 #[derive(Default)]
 struct SharedContext {

compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs

@@ -3,6 +3,7 @@ use std::rc::Rc;
 use crate::ssa::ir::{types::Type, value::ValueId};
 use acvm::FieldElement;
 use fxhash::FxHashMap as HashMap;
+use noirc_frontend::ast;
 use noirc_frontend::hir_def::function::FunctionSignature;
 
 use super::FunctionBuilder;
@@ -33,8 +34,8 @@ impl DataBusBuilder {
 
         for param in &main_signature.0 {
             let is_databus = match param.2 {
-                noirc_frontend::Visibility::Public | noirc_frontend::Visibility::Private => false,
-                noirc_frontend::Visibility::DataBus => true,
+                ast::Visibility::Public | ast::Visibility::Private => false,
+                ast::Visibility::DataBus => true,
             };
             let len = param.1.field_count() as usize;
             params_is_databus.extend(vec![is_databus; len]);

compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs

@@ -4,9 +4,9 @@ use std::sync::{Mutex, RwLock};
 use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::Location;
+use noirc_frontend::ast::{BinaryOpKind, Signedness};
 use noirc_frontend::monomorphization::ast::{self, LocalId, Parameters};
 use noirc_frontend::monomorphization::ast::{FuncId, Program};
-use noirc_frontend::{BinaryOpKind, Signedness};
 
 use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
@@ -562,7 +562,7 @@ impl<'a> FunctionContext<'a> {
     pub(super) fn insert_binary(
         &mut self,
         mut lhs: ValueId,
-        operator: noirc_frontend::BinaryOpKind,
+        operator: BinaryOpKind,
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
@@ -625,7 +625,7 @@ impl<'a> FunctionContext<'a> {
     fn insert_array_equality(
         &mut self,
         lhs: ValueId,
-        operator: noirc_frontend::BinaryOpKind,
+        operator: BinaryOpKind,
         rhs: ValueId,
         location: Location,
     ) -> Values {
@@ -1090,23 +1090,23 @@ impl<'a> FunctionContext<'a> {
 
 /// True if the given operator cannot be encoded directly and needs
 /// to be represented as !(some other operator)
-fn operator_requires_not(op: noirc_frontend::BinaryOpKind) -> bool {
-    use noirc_frontend::BinaryOpKind::*;
+fn operator_requires_not(op: BinaryOpKind) -> bool {
+    use BinaryOpKind::*;
     matches!(op, NotEqual | LessEqual | GreaterEqual)
 }
 
 /// True if the given operator cannot be encoded directly and needs
 /// to have its lhs and rhs swapped to be represented with another operator.
 /// Example: (a > b) needs to be represented as (b < a)
-fn operator_requires_swapped_operands(op: noirc_frontend::BinaryOpKind) -> bool {
-    use noirc_frontend::BinaryOpKind::*;
+fn operator_requires_swapped_operands(op: BinaryOpKind) -> bool {
+    use BinaryOpKind::*;
     matches!(op, Greater | LessEqual)
 }
 
 /// If the operation requires its result to be truncated because it is an integer, the maximum
 /// number of bits that result may occupy is returned.
 fn operator_result_max_bit_size_to_truncate(
-    op: noirc_frontend::BinaryOpKind,
+    op: BinaryOpKind,
     lhs: ValueId,
     rhs: ValueId,
     dfg: &DataFlowGraph,
@@ -1123,7 +1123,7 @@ fn operator_result_max_bit_size_to_truncate(
 
     let lhs_bit_size = get_bit_size(lhs_type)?;
     let rhs_bit_size = get_bit_size(rhs_type)?;
-    use noirc_frontend::BinaryOpKind::*;
+    use BinaryOpKind::*;
     match op {
         Add => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
         Subtract => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
@@ -1173,7 +1173,7 @@ fn operator_result_max_bit_size_to_truncate(
 /// Take care when using this to insert a binary instruction: this requires
 /// checking operator_requires_not and operator_requires_swapped_operands
 /// to represent the full operation correctly.
-fn convert_operator(op: noirc_frontend::BinaryOpKind) -> BinaryOp {
+fn convert_operator(op: BinaryOpKind) -> BinaryOp {
     match op {
         BinaryOpKind::Add => BinaryOp::Add,
         BinaryOpKind::Subtract => BinaryOp::Sub,

compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs

@@ -7,10 +7,8 @@ pub(crate) use program::Ssa;
 use context::SharedContext;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
-use noirc_frontend::{
-    monomorphization::ast::{self, Expression, Program},
-    Visibility,
-};
+use noirc_frontend::ast::{UnaryOp, Visibility};
+use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use crate::{
     errors::{InternalError, RuntimeError},
@@ -306,24 +304,24 @@ impl<'a> FunctionContext<'a> {
 
     fn codegen_unary(&mut self, unary: &ast::Unary) -> Result<Values, RuntimeError> {
         match unary.operator {
-            noirc_frontend::UnaryOp::Not => {
+            UnaryOp::Not => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 let rhs = rhs.into_leaf().eval(self);
                 Ok(self.builder.insert_not(rhs).into())
             }
-            noirc_frontend::UnaryOp::Minus => {
+            UnaryOp::Minus => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 let rhs = rhs.into_leaf().eval(self);
                 let typ = self.builder.type_of_value(rhs);
                 let zero = self.builder.numeric_constant(0u128, typ);
                 Ok(self.insert_binary(
                     zero,
-                    noirc_frontend::BinaryOpKind::Subtract,
+                    noirc_frontend::ast::BinaryOpKind::Subtract,
                     rhs,
                     unary.location,
                 ))
             }
-            noirc_frontend::UnaryOp::MutableReference => {
+            UnaryOp::MutableReference => {
                 Ok(self.codegen_reference(&unary.rhs)?.map(|rhs| {
                     match rhs {
                         value::Value::Normal(value) => {
@@ -338,7 +336,7 @@ impl<'a> FunctionContext<'a> {
                     }
                 }))
             }
-            noirc_frontend::UnaryOp::Dereference { .. } => {
+            UnaryOp::Dereference { .. } => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 Ok(self.dereference(&rhs, &unary.result_type))
             }