chore: Remove the remainder of legacy code

aztec_macros/src/utils/hir_utils.rs

@@ -2,15 +2,15 @@
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast;
+use noirc_frontend::elaborator::Elaborator;
+use noirc_frontend::hir::def_collector::dc_crate::{
+    CollectedItems, UnresolvedFunctions, UnresolvedGlobal,
+};
 use noirc_frontend::macros_api::{HirExpression, HirLiteral};
 use noirc_frontend::node_interner::{NodeInterner, TraitImplKind};
 use noirc_frontend::{
     graph::CrateId,
-    hir::{
-        def_map::{LocalModuleId, ModuleId},
-        resolution::{path_resolver::StandardPathResolver, resolver::Resolver},
-        type_check::type_check_func,
-    },
+    hir::def_map::{LocalModuleId, ModuleId},
     macros_api::{FileId, HirContext, MacroError, ModuleDefId, StructId},
     node_interner::{FuncId, TraitId},
     Shared, StructType, Type,
@@ -190,24 +190,17 @@
             span: None,
         })?;
 
-    let def_maps = &mut context.def_maps;
-
-    let path_resolver =
-        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
-
-    let resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
-
-    let (hir_func, meta, _) = resolver.resolve_function(func, func_id);
+    let mut items = CollectedItems::default();
+    let functions = vec![(module_id, func_id, func)];
+    let trait_id = None;
+    items.functions.push(UnresolvedFunctions { file_id, functions, trait_id, self_type: None });
 
-    context.def_interner.push_fn_meta(meta, func_id);
-    context.def_interner.update_fn(func_id, hir_func);
-
-    let errors = type_check_func(&mut context.def_interner, func_id);
+    let errors = Elaborator::elaborate(context, *crate_id, items, None);
 
     if !errors.is_empty() {
         return Err(MacroError {
             primary_message: "Failed to type check autogenerated function".to_owned(),
-            secondary_message: Some(errors.iter().map(|err| err.to_string()).collect::<String>()),
+            secondary_message: Some(errors.iter().map(|err| err.0.to_string()).collect::<String>()),
             span: None,
         });
     }
@@ -243,17 +236,10 @@
             )
         });
 
-    let def_maps = &mut context.def_maps;
-
-    let path_resolver =
-        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
-
-    let mut resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
-
-    let hir_stmt = resolver.resolve_global_let(global, global_id);
+    let mut items = CollectedItems::default();
+    items.globals.push(UnresolvedGlobal { file_id, module_id, global_id, stmt_def: global });
 
-    let statement_id = context.def_interner.get_global(global_id).let_statement;
-    context.def_interner.replace_statement(statement_id, hir_stmt);
+    let _errors = Elaborator::elaborate(context, *crate_id, items, None);
 }
 
 pub fn fully_qualified_note_path(context: &HirContext, note_id: StructId) -> Option<String> {
@@ -347,7 +333,7 @@
     }
 }
 
 pub fn get_global_numberic_const(
     context: &HirContext,
     const_name: &str,
 ) -> Result<u128, MacroError> {

compiler/noirc_driver/src/lib.rs

@@ -99,10 +99,6 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub force_brillig: bool,
 
-    /// Use the deprecated name resolution & type checking passes instead of the elaborator
-    #[arg(long, hide = true)]
-    pub use_legacy: bool,
-
     /// Enable printing results of comptime evaluation: provide a path suffix
     /// for the module to debug, e.g. "package_name/src/main.nr"
     #[arg(long)]
@@ -262,15 +258,13 @@ pub fn check_crate(
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
-    use_legacy: bool,
     debug_comptime_in_file: Option<&str>,
 ) -> CompilationResult<()> {
     let macros: &[&dyn MacroProcessor] =
         if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
-    let diagnostics =
-        CrateDefMap::collect_defs(crate_id, context, use_legacy, debug_comptime_in_file, macros);
+    let diagnostics = CrateDefMap::collect_defs(crate_id, context, debug_comptime_in_file, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -307,7 +301,6 @@ pub fn compile_main(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_legacy,
         options.debug_comptime_in_file.as_deref(),
     )?;
 
@@ -349,7 +342,6 @@ pub fn compile_contract(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_legacy,
         options.debug_comptime_in_file.as_deref(),
     )?;
 

compiler/noirc_driver/tests/stdlib_warnings.rs

@@ -25,7 +25,7 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let root_crate_id = prepare_crate(&mut context, file_name);
 
     let ((), warnings) =
-        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false, None)?;
+        noirc_driver::check_crate(&mut context, root_crate_id, false, false, None)?;
 
     assert_eq!(warnings, Vec::new(), "stdlib is producing {} warnings", warnings.len());
 

compiler/noirc_frontend/src/ast/statement.rs

@@ -10,7 +10,7 @@ use super::{
     BlockExpression, Expression, ExpressionKind, IndexExpression, MemberAccessExpression,
     MethodCallExpression, UnresolvedType,
 };
-use crate::hir::resolution::resolver::SELF_TYPE_NAME;
+use crate::elaborator::types::SELF_TYPE_NAME;
 use crate::lexer::token::SpannedToken;
 use crate::macros_api::SecondaryAttribute;
 use crate::parser::{ParserError, ParserErrorReason};

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -10,7 +10,7 @@ use crate::{
     },
     hir::{
         comptime::{self, InterpreterError},
-        resolution::{errors::ResolverError, resolver::LambdaContext},
+        resolution::errors::ResolverError,
         type_check::TypeCheckError,
     },
     hir_def::{
@@ -32,7 +32,7 @@ use crate::{
     QuotedType, Shared, StructType, Type,
 };
 
-use super::Elaborator;
+use super::{Elaborator, LambdaContext};
 
 impl<'context> Elaborator<'context> {
     pub(super) fn elaborate_expression(&mut self, expr: Expression) -> (ExprId, Type) {

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -16,12 +16,12 @@ use crate::{
             dc_mod,
             errors::DuplicateType,
         },
-        resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
+        resolution::{errors::ResolverError, path_resolver::PathResolver},
         scope::ScopeForest as GenericScopeForest,
-        type_check::{check_trait_impl_method_matches_declaration, TypeCheckError},
+        type_check::TypeCheckError,
     },
     hir_def::{
-        expr::HirIdent,
+        expr::{HirCapturedVar, HirIdent},
         function::{FunctionBody, Parameters},
         traits::TraitConstraint,
         types::{Generics, Kind, ResolvedGeneric},
@@ -67,14 +67,16 @@ mod patterns;
 mod scope;
 mod statements;
 mod traits;
-mod types;
+pub mod types;
 mod unquote;
 
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
+use self::traits::check_trait_impl_method_matches_declaration;
+
 /// ResolverMetas are tagged onto each definition to track how many times they are used
 #[derive(Debug, PartialEq, Eq)]
 pub struct ResolverMeta {
@@ -85,6 +87,13 @@ pub struct ResolverMeta {
 
 type ScopeForest = GenericScopeForest<String, ResolverMeta>;
 
+pub struct LambdaContext {
+    pub captures: Vec<HirCapturedVar>,
+    /// the index in the scope tree
+    /// (sometimes being filled by ScopeTree's find method)
+    pub scope_index: usize,
+}
+
 pub struct Elaborator<'context> {
     scopes: ScopeForest,
 

compiler/noirc_frontend/src/elaborator/scope.rs

@@ -3,7 +3,6 @@ use noirc_errors::{Location, Spanned};
 use crate::ast::ERROR_IDENT;
 use crate::hir::def_map::{LocalModuleId, ModuleId};
 use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
-use crate::hir::resolution::resolver::SELF_TYPE_NAME;
 use crate::hir::scope::{Scope as GenericScope, ScopeTree as GenericScopeTree};
 use crate::macros_api::Ident;
 use crate::{
@@ -21,6 +20,7 @@ use crate::{
 };
 use crate::{Type, TypeAlias};
 
+use super::types::SELF_TYPE_NAME;
 use super::{Elaborator, ResolverMeta};
 
 type Scope = GenericScope<String, ResolverMeta>;