fn next_register in CodeGeneratingVisitor.

It's error prone to fetch and increment the
next register manually each time.

Author: mikebenfield

compiler/passes/src/code_generation/expression.rs

@@ -134,12 +134,9 @@ impl CodeGeneratingVisitor<'_> {
             BinaryOperation::Xor => String::from("xor"),
         };
 
-        let destination_register = format!("r{}", self.next_register);
+        let destination_register = self.next_register();
         let binary_instruction = format!("    {opcode} {left_operand} {right_operand} into {destination_register};\n",);
 
-        // Increment the register counter.
-        self.next_register += 1;
-
         // Concatenate the instructions.
         let mut instructions = left_instructions;
         instructions.push_str(&right_instructions);
@@ -152,9 +149,7 @@ impl CodeGeneratingVisitor<'_> {
         let (expression_operand, mut instructions) = self.visit_expression(&input.expression);
 
         // Construct the destination register.
-        let destination_register = format!("r{}", self.next_register);
-        // Increment the register counter.
-        self.next_register += 1;
+        let destination_register = self.next_register();
 
         let cast_instruction = format!(
             "    cast {expression_operand} into {destination_register} as {};\n",
@@ -177,9 +172,7 @@ impl CodeGeneratingVisitor<'_> {
         }
 
         // Construct the destination register.
-        let destination_register = format!("r{}", self.next_register);
-        // Increment the register counter.
-        self.next_register += 1;
+        let destination_register = self.next_register();
 
         // Get the array type.
         let Some(array_type @ Type::Array(..)) = self.state.type_table.get(&input.id) else {
@@ -213,12 +206,9 @@ impl CodeGeneratingVisitor<'_> {
             UnaryOperation::ToYCoordinate => ("cast", " as group.y"),
         };
 
-        let destination_register = format!("r{}", self.next_register);
+        let destination_register = self.next_register();
         let unary_instruction = format!("    {opcode} {expression_operand} into {destination_register}{suffix};\n");
 
-        // Increment the register counter.
-        self.next_register += 1;
-
         // Concatenate the instructions.
         let mut instructions = expression_instructions;
         instructions.push_str(&unary_instruction);
@@ -231,14 +221,11 @@ impl CodeGeneratingVisitor<'_> {
         let (if_true_operand, if_true_instructions) = self.visit_expression(&input.if_true);
         let (if_false_operand, if_false_instructions) = self.visit_expression(&input.if_false);
 
-        let destination_register = format!("r{}", self.next_register);
+        let destination_register = self.next_register();
         let ternary_instruction = format!(
             "    ternary {condition_operand} {if_true_operand} {if_false_operand} into {destination_register};\n",
         );
 
-        // Increment the register counter.
-        self.next_register += 1;
-
         // Concatenate the instructions.
         let mut instructions = condition_instructions;
         instructions.push_str(&if_true_instructions);
@@ -287,15 +274,12 @@ impl CodeGeneratingVisitor<'_> {
         }
 
         // Push destination register to struct init instruction.
-        let destination_register = format!("r{}", self.next_register);
+        let destination_register = self.next_register();
         writeln!(struct_init_instruction, "into {destination_register} as {name};",)
             .expect("failed to write to string");
 
         instructions.push_str(&struct_init_instruction);
 
-        // Increment the register counter.
-        self.next_register += 1;
-
         (destination_register, instructions)
     }
 
@@ -339,13 +323,6 @@ impl CodeGeneratingVisitor<'_> {
             })
             .collect::<Vec<_>>();
 
-        // Helper function to get a destination register for a function call.
-        let mut get_destination_register = || {
-            let destination_register = format!("r{}", self.next_register);
-            self.next_register += 1;
-            destination_register
-        };
-
         // Helper function to construct the instruction associated with a simple function call.
         // This assumes that the function call has one output.
         let mut construct_simple_function_call = |function: &Identifier, variant: &str, arguments: Vec<String>| {
@@ -359,7 +336,7 @@ impl CodeGeneratingVisitor<'_> {
             for argument in arguments {
                 write!(instruction, " {argument}").expect("failed to write to string");
             }
-            let destination_register = get_destination_register();
+            let destination_register = self.next_register();
             writeln!(instruction, " into {destination_register} as {return_type};").expect("failed to write to string");
             (destination_register, instruction)
         };
@@ -384,15 +361,15 @@ impl CodeGeneratingVisitor<'_> {
             sym::Mapping => match input.name.name {
                 sym::get => {
                     let mut instruction = "    get".to_string();
-                    let destination_register = get_destination_register();
+                    let destination_register = self.next_register();
                     // Write the mapping name and the key.
                     writeln!(instruction, " {}[{}] into {destination_register};", arguments[0], arguments[1])
                         .expect("failed to write to string");
                     (destination_register, instruction)
                 }
                 sym::get_or_use => {
                     let mut instruction = "    get.or_use".to_string();
-                    let destination_register = get_destination_register();
+                    let destination_register = self.next_register();
                     // Write the mapping name, the key, and the default value.
                     writeln!(
                         instruction,
@@ -417,7 +394,7 @@ impl CodeGeneratingVisitor<'_> {
                 }
                 sym::contains => {
                     let mut instruction = "    contains".to_string();
-                    let destination_register = get_destination_register();
+                    let destination_register = self.next_register();
                     // Write the mapping name and the key.
                     writeln!(instruction, " {}[{}] into {destination_register};", arguments[0], arguments[1])
                         .expect("failed to write to string");
@@ -429,15 +406,15 @@ impl CodeGeneratingVisitor<'_> {
                 match input.name {
                     Identifier { name: sym::to_x_coordinate, .. } => {
                         let mut instruction = "    cast".to_string();
-                        let destination_register = get_destination_register();
+                        let destination_register = self.next_register();
                         // Write the argument and the destination register.
                         writeln!(instruction, " {} into {destination_register} as group.x;", arguments[0],)
                             .expect("failed to write to string");
                         (destination_register, instruction)
                     }
                     Identifier { name: sym::to_y_coordinate, .. } => {
                         let mut instruction = "    cast".to_string();
-                        let destination_register = get_destination_register();
+                        let destination_register = self.next_register();
                         // Write the argument and the destination register.
                         writeln!(instruction, " {} into {destination_register} as group.y;", arguments[0],)
                             .expect("failed to write to string");
@@ -448,7 +425,7 @@ impl CodeGeneratingVisitor<'_> {
             }
             sym::ChaCha => {
                 // Get the destination register.
-                let destination_register = get_destination_register();
+                let destination_register = self.next_register();
                 // Construct the instruction template.
                 let mut instruction = format!("    rand.chacha into {destination_register} as ");
                 // Write the return type.
@@ -475,7 +452,7 @@ impl CodeGeneratingVisitor<'_> {
             }
             sym::signature => {
                 let mut instruction = "    sign.verify".to_string();
-                let destination_register = get_destination_register();
+                let destination_register = self.next_register();
                 // Write the arguments and the destination register.
                 writeln!(
                     instruction,
@@ -552,24 +529,18 @@ impl CodeGeneratingVisitor<'_> {
                 0 | 1 => panic!("Parsing guarantees that a tuple type has at least two elements"),
                 len => {
                     for _ in 0..len {
-                        let destination_register = format!("r{}", self.next_register);
-                        destinations.push(destination_register);
-                        self.next_register += 1;
+                        destinations.push(self.next_register());
                     }
                 }
             },
             _ => {
-                let destination_register = format!("r{}", self.next_register);
-                destinations.push(destination_register);
-                self.next_register += 1;
+                destinations.push(self.next_register());
             }
         }
 
         // Add a register for async functions to represent the future created.
         if func_symbol.function.variant == Variant::AsyncFunction {
-            let destination_register = format!("r{}", self.next_register);
-            destinations.push(destination_register);
-            self.next_register += 1;
+            destinations.push(self.next_register());
         }
 
         // Construct the output operands. These are the destination registers **without** the future.
@@ -615,8 +586,7 @@ impl CodeGeneratingVisitor<'_> {
     }
 
     pub fn clone_register(&mut self, register: &str, typ: &Type) -> (String, String) {
-        let new_reg = format!("r{}", self.next_register);
-        self.next_register += 1;
+        let new_reg = self.next_register();
         match typ {
             Type::Address
             | Type::Boolean

compiler/passes/src/code_generation/program.rs

@@ -185,8 +185,7 @@ impl<'a> CodeGeneratingVisitor<'a> {
 
         // Construct and append the input declarations of the function.
         for input in function.input.iter() {
-            let register_string = format!("r{}", self.next_register);
-            self.next_register += 1;
+            let register_string = self.next_register();
 
             // Track all internal record inputs.
             if let Type::Composite(comp) = &input.type_ {

compiler/passes/src/code_generation/visitor.rs

@@ -51,3 +51,10 @@ pub struct CodeGeneratingVisitor<'a> {
     /// This is necessary as if we output them, we need to clone them.
     pub internal_record_inputs: IndexSet<String>,
 }
+
+impl CodeGeneratingVisitor<'_> {
+    pub fn next_register(&mut self) -> String {
+        self.next_register += 1;
+        format!("r{}", self.next_register - 1)
+    }
+}

errors/src/errors/type_checker/type_checker_error.rs

@@ -1031,6 +1031,7 @@ create_messages!(
         msg: format!("Invalid annotation: {message}."),
         help: None,
     }
+
     @formatted
     ternary_over_external_records {
         args: (ty: impl Display),