chore(experimental): Add compiler option to enable the Elaborator

compiler/noirc_driver/src/lib.rs

@@ -103,6 +103,10 @@ pub struct CompileOptions {
     /// Force Brillig output (for step debugging)
     #[arg(long, hide = true)]
     pub force_brillig: bool,
+
+    /// Enable the experimental elaborator pass
+    #[arg(long, hide = true)]
+    pub use_elaborator: bool,
 }
 
 fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
@@ -245,12 +249,13 @@ pub fn check_crate(
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
+    use_elaborator: bool,
 ) -> 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, macros);
+    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_elaborator, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -282,8 +287,13 @@ pub fn compile_main(
     options: &CompileOptions,
     cached_program: Option<CompiledProgram>,
 ) -> CompilationResult<CompiledProgram> {
-    let (_, mut warnings) =
-        check_crate(context, crate_id, options.deny_warnings, options.disable_macros)?;
+    let (_, mut warnings) = check_crate(
+        context,
+        crate_id,
+        options.deny_warnings,
+        options.disable_macros,
+        options.use_elaborator,
+    )?;
 
     let main = context.get_main_function(&crate_id).ok_or_else(|| {
         // TODO(#2155): This error might be a better to exist in Nargo
@@ -318,8 +328,13 @@ pub fn compile_contract(
     crate_id: CrateId,
     options: &CompileOptions,
 ) -> CompilationResult<CompiledContract> {
-    let (_, warnings) =
-        check_crate(context, crate_id, options.deny_warnings, options.disable_macros)?;
+    let (_, warnings) = check_crate(
+        context,
+        crate_id,
+        options.deny_warnings,
+        options.disable_macros,
+        options.use_elaborator,
+    )?;
 
     // TODO: We probably want to error if contracts is empty
     let contracts = context.get_all_contracts(&crate_id);

compiler/noirc_driver/tests/stdlib_warnings.rs

@@ -24,7 +24,8 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let mut context = Context::new(file_manager, parsed_files);
     let root_crate_id = prepare_crate(&mut context, file_name);
 
-    let ((), warnings) = noirc_driver::check_crate(&mut context, root_crate_id, false, false)?;
+    let ((), warnings) =
+        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false)?;
 
     assert_eq!(warnings, Vec::new(), "stdlib is producing warnings");
 

compiler/noirc_frontend/src/ast/function.rs

@@ -32,6 +32,15 @@ pub enum FunctionKind {
     Recursive,
 }
 
+impl FunctionKind {
+    pub fn can_ignore_return_type(self) -> bool {
+        match self {
+            FunctionKind::LowLevel | FunctionKind::Builtin | FunctionKind::Oracle => true,
+            FunctionKind::Normal | FunctionKind::Recursive => false,
+        }
+    }
+}
+
 impl NoirFunction {
     pub fn normal(def: FunctionDefinition) -> NoirFunction {
         NoirFunction { kind: FunctionKind::Normal, def }

compiler/noirc_frontend/src/ast/statement.rs

@@ -565,7 +565,7 @@ impl ForRange {
         identifier: Ident,
         block: Expression,
         for_loop_span: Span,
-    ) -> StatementKind {
+    ) -> Statement {
         /// Counter used to generate unique names when desugaring
         /// code in the parser requires the creation of fresh variables.
         /// The parser is stateless so this is a static global instead.
@@ -662,7 +662,8 @@ impl ForRange {
                 let block = ExpressionKind::Block(BlockExpression {
                     statements: vec![let_array, for_loop],
                 });
-                StatementKind::Expression(Expression::new(block, for_loop_span))
+                let kind = StatementKind::Expression(Expression::new(block, for_loop_span));
+                Statement { kind, span: for_loop_span }
             }
         }
     }