Merge pull request #28975 from ProvableHQ/IGI-111/empty-loops

Allow empty loops

Author: IGI-111

compiler/passes/src/loop_unrolling/ast.rs

@@ -16,8 +16,6 @@
 
 use leo_ast::{Expression::Literal, interpreter_value::literal_to_value, *};
 
-use leo_errors::LoopUnrollerError;
-
 use super::UnrollingVisitor;
 
 impl AstReconstructor for UnrollingVisitor<'_> {
@@ -107,14 +105,19 @@ impl AstReconstructor for UnrollingVisitor<'_> {
         let stop_value =
             literal_to_value(&resolved_stop_lit, &None).expect("Parsing and type checking guarantee this works.");
 
-        // Ensure loop bounds are strictly increasing
-        if start_value.gte(&stop_value).expect("Type checking guarantees these are the same type") {
-            self.emit_err(LoopUnrollerError::loop_range_decreasing(input.stop.span()));
-        }
-
         self.loop_unrolled = true;
 
         // Actually unroll.
-        (self.unroll_iteration_statement(input, start_value, stop_value), Default::default())
+        (
+            if start_value.gte(&stop_value).expect("Type checking guarantees these are the same type") {
+                let new_block_id = self.state.node_builder.next_id();
+                self.in_scope(new_block_id, |_| {
+                    Statement::from(Block { span: input.span, statements: vec![], id: new_block_id })
+                })
+            } else {
+                self.unroll_iteration_statement(input, start_value, stop_value)
+            },
+            Default::default(),
+        )
     }
 }

compiler/passes/src/loop_unrolling/visitor.rs

@@ -50,11 +50,6 @@ impl UnrollingVisitor<'_> {
         result
     }
 
-    /// Emits a Loop Unrolling Error
-    pub fn emit_err(&self, err: LoopUnrollerError) {
-        self.state.handler.emit_err(err);
-    }
-
     /// Unrolls an IterationStatement.
     pub fn unroll_iteration_statement(&mut self, input: IterationStatement, start: Value, stop: Value) -> Statement {
         // We already know these are integers since loop unrolling occurs after type checking.

compiler/passes/src/static_analysis/visitor.rs

@@ -39,7 +39,7 @@ impl StaticAnalyzingVisitor<'_> {
 
     /// Emits a type checker warning
     pub fn emit_warning(&self, warning: StaticAnalyzerWarning) {
-        self.state.handler.emit_warning(warning.into());
+        self.state.handler.emit_warning(warning);
     }
 
     /// Type checks the awaiting of a future.

compiler/passes/src/symbol_table_creation/mod.rs

@@ -35,7 +35,7 @@ use leo_ast::{
     Type,
     Variant,
 };
-use leo_errors::{LeoError, Result};
+use leo_errors::Result;
 use leo_span::{Span, Symbol};
 
 use indexmap::IndexMap;
@@ -146,7 +146,7 @@ impl ProgramVisitor for SymbolTableCreationVisitor<'_> {
         if !input.is_record {
             if let Some(prev_span) = self.structs.get(&full_name) {
                 // The struct already existed
-                return self.state.handler.emit_err::<LeoError>(SymbolTable::emit_shadow_error(
+                return self.state.handler.emit_err(SymbolTable::emit_shadow_error(
                     input.identifier.name,
                     input.identifier.span,
                     *prev_span,

compiler/passes/src/type_checking/visitor.rs

@@ -80,7 +80,7 @@ impl TypeCheckingVisitor<'_> {
     /// Emits a type checker warning
     pub fn emit_warning(&mut self, warning: TypeCheckerWarning) {
         if self.state.warnings.insert(warning.clone().into()) {
-            self.state.handler.emit_warning(warning.into());
+            self.state.handler.emit_warning(warning);
         }
     }
 

errors/src/emitter/mod.rs

@@ -187,17 +187,17 @@ impl Handler {
     }
 
     /// Emit the error `err`.
-    pub fn emit_err<E: Into<LeoError>>(&self, err: E) {
+    pub fn emit_err(&self, err: impl Into<LeoError>) {
         let mut inner = self.inner.borrow_mut();
         inner.err_count = inner.err_count.saturating_add(1);
         inner.emitter.emit_err(err.into());
     }
 
     /// Emit the error `err`.
-    pub fn emit_warning(&self, warning: LeoWarning) {
+    pub fn emit_warning(&self, warning: impl Into<LeoWarning>) {
         let mut inner = self.inner.borrow_mut();
         inner.warn_count = inner.warn_count.saturating_add(1);
-        inner.emitter.emit_warning(warning);
+        inner.emitter.emit_warning(warning.into());
     }
 
     /// The number of errors thus far.

errors/src/errors/loop_unroller/loop_unroller_errors.rs

@@ -23,6 +23,7 @@ create_messages!(
     code_mask: 9000i32,
     code_prefix: "LUN",
 
+    // TODO This error is unused. Remove it in a future version.
     @formatted
     loop_range_decreasing {
         args: (),

tests/expectations/compiler/constants/decreasing_constant_loop_bound_fail.out

@@ -1,5 +1,7 @@
-Error [ELUN0379000]: The loop range must be increasing.
-    --> compiler-test:5:26
-     |
-   5 |         const STOP: u8 = 0u8;
-     |                          ^^^
+program test.aleo;
+
+function foo:
+    input r0 as u8.private;
+    input r1 as u8.private;
+    input r2 as boolean.private;
+    output 1u8 as u8.private;

tests/expectations/compiler/statements/loop_decreasing_fail.out

@@ -0,0 +1,5 @@
+program test.aleo;
+
+function main:
+    input r0 as u32.private;
+    output true as boolean.private;